]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - drivers/firewire/fw-card.c
firewire: Fix bit shift typo.
[mirror_ubuntu-zesty-kernel.git] / drivers / firewire / fw-card.c
CommitLineData
3038e353
KH
1/* -*- c-basic-offset: 8 -*-
2 *
3 * fw-card.c - card level functions
4 *
5 * Copyright (C) 2005-2006 Kristian Hoegsberg <krh@bitplanet.net>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software Foundation,
19 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 */
21
22#include <linux/module.h>
23#include <linux/errno.h>
24#include <linux/device.h>
25#include "fw-transaction.h"
26#include "fw-topology.h"
19a15b93 27#include "fw-device.h"
3038e353
KH
28
29/* The lib/crc16.c implementation uses the standard (0x8005)
30 * polynomial, but we need the ITU-T (or CCITT) polynomial (0x1021).
31 * The implementation below works on an array of host-endian u32
32 * words, assuming they'll be transmited msb first. */
33static u16
34crc16_itu_t(const u32 *buffer, size_t length)
35{
36 int shift, i;
37 u32 data;
38 u16 sum, crc = 0;
39
40 for (i = 0; i < length; i++) {
41 data = *buffer++;
42 for (shift = 28; shift >= 0; shift -= 4 ) {
43 sum = ((crc >> 12) ^ (data >> shift)) & 0xf;
44 crc = (crc << 4) ^ (sum << 12) ^ (sum << 5) ^ (sum);
45 }
46 crc &= 0xffff;
47 }
48
49 return crc;
50}
51
52static LIST_HEAD(card_list);
53
54static LIST_HEAD(descriptor_list);
55static int descriptor_count;
56
57#define bib_crc(v) ((v) << 0)
58#define bib_crc_length(v) ((v) << 16)
59#define bib_info_length(v) ((v) << 24)
60
61#define bib_link_speed(v) ((v) << 0)
62#define bib_generation(v) ((v) << 4)
63#define bib_max_rom(v) ((v) << 8)
64#define bib_max_receive(v) ((v) << 12)
65#define bib_cyc_clk_acc(v) ((v) << 16)
66#define bib_pmc ((1) << 27)
67#define bib_bmc ((1) << 28)
68#define bib_isc ((1) << 29)
69#define bib_cmc ((1) << 30)
70#define bib_imc ((1) << 31)
71
72static u32 *
73generate_config_rom (struct fw_card *card, size_t *config_rom_length)
74{
75 struct fw_descriptor *desc;
76 static u32 config_rom[256];
77 int i, j, length;
78
5e20c282
SR
79 /* Initialize contents of config rom buffer. On the OHCI
80 * controller, block reads to the config rom accesses the host
81 * memory, but quadlet read access the hardware bus info block
82 * registers. That's just crack, but it means we should make
83 * sure the contents of bus info block in host memory mathces
84 * the version stored in the OHCI registers. */
3038e353
KH
85
86 memset(config_rom, 0, sizeof config_rom);
87 config_rom[0] = bib_crc_length(4) | bib_info_length(4) | bib_crc(0);
88 config_rom[1] = 0x31333934;
89
90 config_rom[2] =
91 bib_link_speed(card->link_speed) |
92 bib_generation(card->config_rom_generation++ % 14 + 2) |
93 bib_max_rom(2) |
94 bib_max_receive(card->max_receive) |
95 bib_isc | bib_cmc | bib_imc;
96 config_rom[3] = card->guid >> 32;
97 config_rom[4] = card->guid;
98
99 /* Generate root directory. */
100 i = 5;
101 config_rom[i++] = 0;
102 config_rom[i++] = 0x0c0083c0; /* node capabilities */
103 config_rom[i++] = 0x03d00d1e; /* vendor id */
104 j = i + descriptor_count;
105
106 /* Generate root directory entries for descriptors. */
107 list_for_each_entry (desc, &descriptor_list, link) {
108 config_rom[i] = desc->key | (j - i);
109 i++;
110 j += desc->length;
111 }
112
113 /* Update root directory length. */
114 config_rom[5] = (i - 5 - 1) << 16;
115
116 /* End of root directory, now copy in descriptors. */
117 list_for_each_entry (desc, &descriptor_list, link) {
118 memcpy(&config_rom[i], desc->data, desc->length * 4);
119 i += desc->length;
120 }
121
122 /* Calculate CRCs for all blocks in the config rom. This
123 * assumes that CRC length and info length are identical for
124 * the bus info block, which is always the case for this
125 * implementation. */
126 for (i = 0; i < j; i += length + 1) {
127 length = (config_rom[i] >> 16) & 0xff;
128 config_rom[i] |= crc16_itu_t(&config_rom[i + 1], length);
129 }
130
131 *config_rom_length = j;
132
133 return config_rom;
134}
135
136static void
137update_config_roms (void)
138{
139 struct fw_card *card;
140 u32 *config_rom;
141 size_t length;
142
143 list_for_each_entry (card, &card_list, link) {
144 config_rom = generate_config_rom(card, &length);
145 card->driver->set_config_rom(card, config_rom, length);
146 }
147}
148
149int
150fw_core_add_descriptor (struct fw_descriptor *desc)
151{
152 size_t i;
153
154 /* Check descriptor is valid; the length of all blocks in the
155 * descriptor has to add up to exactly the length of the
156 * block. */
157 i = 0;
158 while (i < desc->length)
159 i += (desc->data[i] >> 16) + 1;
160
161 if (i != desc->length)
162 return -1;
163
164 down_write(&fw_bus_type.subsys.rwsem);
165
166 list_add_tail (&desc->link, &descriptor_list);
167 descriptor_count++;
168 update_config_roms();
169
170 up_write(&fw_bus_type.subsys.rwsem);
171
172 return 0;
173}
174EXPORT_SYMBOL(fw_core_add_descriptor);
175
176void
177fw_core_remove_descriptor (struct fw_descriptor *desc)
178{
179 down_write(&fw_bus_type.subsys.rwsem);
180
181 list_del(&desc->link);
182 descriptor_count--;
183 update_config_roms();
184
185 up_write(&fw_bus_type.subsys.rwsem);
186}
187EXPORT_SYMBOL(fw_core_remove_descriptor);
188
83db801c
KH
189static const char gap_count_table[] = {
190 63, 5, 7, 8, 10, 13, 16, 18, 21, 24, 26, 29, 32, 35, 37, 40
191};
192
19a15b93
KH
193static void
194fw_card_irm_work(struct work_struct *work)
195{
83db801c 196 struct fw_card *card = container_of(work, struct fw_card, work.work);
19a15b93
KH
197 struct fw_device *root;
198 unsigned long flags;
83db801c 199 int root_id, new_irm_id, gap_count, generation, do_reset = 0;
19a15b93
KH
200
201 /* FIXME: This simple bus management unconditionally picks a
202 * cycle master if the current root can't do it. We need to
203 * not do this if there is a bus manager already. Also, some
204 * hubs set the contender bit, which is bogus, so we should
205 * probably do a little sanity check on the IRM (like, read
206 * the bandwidth register) if it's not us. */
207
208 spin_lock_irqsave(&card->lock, flags);
209
210 generation = card->generation;
211 root = card->root_node->data;
83db801c 212 root_id = card->root_node->node_id;
19a15b93 213
83db801c 214 if (root == NULL) {
19a15b93
KH
215 /* Either link_on is false, or we failed to read the
216 * config rom. In either case, pick another root. */
217 new_irm_id = card->local_node->node_id;
83db801c 218 } else if (root->state != FW_DEVICE_RUNNING) {
19a15b93
KH
219 /* If we haven't probed this device yet, bail out now
220 * and let's try again once that's done. */
83db801c
KH
221 new_irm_id = root_id;
222 } else if (root->config_rom[2] & bib_cmc) {
19a15b93
KH
223 /* FIXME: I suppose we should set the cmstr bit in the
224 * STATE_CLEAR register of this node, as described in
225 * 1394-1995, 8.4.2.6. Also, send out a force root
226 * packet for this node. */
83db801c
KH
227 new_irm_id = root_id;
228 } else {
19a15b93
KH
229 /* Current root has an active link layer and we
230 * successfully read the config rom, but it's not
231 * cycle master capable. */
232 new_irm_id = card->local_node->node_id;
83db801c
KH
233 }
234
235 /* Now figure out what gap count to set. */
236 if (card->topology_type == FW_TOPOLOGY_A &&
237 card->root_node->max_hops < ARRAY_SIZE(gap_count_table))
238 gap_count = gap_count_table[card->root_node->max_hops];
239 else
240 gap_count = 63;
241
242 /* Finally, figure out if we should do a reset or not. If we've
243 * done less that 5 resets with the same physical topology and we
244 * have either a new root or a new gap count setting, let's do it. */
19a15b93 245
83db801c
KH
246 if (card->irm_retries++ < 5 &&
247 (card->gap_count != gap_count || new_irm_id != root_id))
248 do_reset = 1;
19a15b93
KH
249
250 spin_unlock_irqrestore(&card->lock, flags);
251
83db801c
KH
252 if (do_reset) {
253 fw_notify("phy config: card %d, new root=%x, gap_count=%d\n",
254 card->index, new_irm_id, gap_count);
255 fw_send_phy_config(card, new_irm_id, generation, gap_count);
19a15b93
KH
256 fw_core_initiate_bus_reset(card, 1);
257 }
258}
259
3038e353
KH
260static void
261release_card(struct device *device)
262{
263 struct fw_card *card =
264 container_of(device, struct fw_card, card_device);
265
266 kfree(card);
267}
268
269static void
270flush_timer_callback(unsigned long data)
271{
272 struct fw_card *card = (struct fw_card *)data;
273
274 fw_flush_transactions(card);
275}
276
277void
21ebcd12 278fw_card_initialize(struct fw_card *card, const struct fw_card_driver *driver,
3038e353
KH
279 struct device *device)
280{
281 static int index;
282
283 card->index = index++;
5e20c282 284 card->driver = driver;
3038e353 285 card->device = device;
5e20c282
SR
286 card->current_tlabel = 0;
287 card->tlabel_mask = 0;
3038e353
KH
288 card->color = 0;
289
5e20c282 290 INIT_LIST_HEAD(&card->transaction_list);
3038e353
KH
291 spin_lock_init(&card->lock);
292 setup_timer(&card->flush_timer,
293 flush_timer_callback, (unsigned long)card);
294
295 card->local_node = NULL;
296
19a15b93
KH
297 INIT_DELAYED_WORK(&card->work, fw_card_irm_work);
298
3038e353
KH
299 card->card_device.bus = &fw_bus_type;
300 card->card_device.release = release_card;
301 card->card_device.parent = card->device;
302 snprintf(card->card_device.bus_id, sizeof card->card_device.bus_id,
303 "fwcard%d", card->index);
304
305 device_initialize(&card->card_device);
306}
307EXPORT_SYMBOL(fw_card_initialize);
308
309int
310fw_card_add(struct fw_card *card,
311 u32 max_receive, u32 link_speed, u64 guid)
312{
313 int retval;
314 u32 *config_rom;
315 size_t length;
316
317 card->max_receive = max_receive;
318 card->link_speed = link_speed;
319 card->guid = guid;
320
321 /* FIXME: add #define's for phy registers. */
322 /* Activate link_on bit and contender bit in our self ID packets.*/
323 if (card->driver->update_phy_reg(card, 4, 0, 0x80 | 0x40) < 0)
324 return -EIO;
325
326 retval = device_add(&card->card_device);
327 if (retval < 0) {
5e20c282 328 fw_error("Failed to register card device.");
3038e353
KH
329 return retval;
330 }
331
332 /* The subsystem grabs a reference when the card is added and
333 * drops it when the driver calls fw_core_remove_card. */
334 fw_card_get(card);
335
336 down_write(&fw_bus_type.subsys.rwsem);
337 config_rom = generate_config_rom (card, &length);
338 list_add_tail(&card->link, &card_list);
339 up_write(&fw_bus_type.subsys.rwsem);
340
341 return card->driver->enable(card, config_rom, length);
342}
343EXPORT_SYMBOL(fw_card_add);
344
345
346/* The next few functions implements a dummy driver that use once a
347 * card driver shuts down an fw_card. This allows the driver to
348 * cleanly unload, as all IO to the card will be handled by the dummy
349 * driver instead of calling into the (possibly) unloaded module. The
350 * dummy driver just fails all IO. */
351
352static int
353dummy_enable(struct fw_card *card, u32 *config_rom, size_t length)
354{
355 BUG();
356 return -1;
357}
358
359static int
360dummy_update_phy_reg(struct fw_card *card, int address,
361 int clear_bits, int set_bits)
362{
363 return -ENODEV;
364}
365
366static int
367dummy_set_config_rom(struct fw_card *card,
368 u32 *config_rom, size_t length)
369{
370 /* We take the card out of card_list before setting the dummy
371 * driver, so this should never get called. */
372 BUG();
373 return -1;
374}
375
376static void
377dummy_send_request(struct fw_card *card, struct fw_packet *packet)
378{
5e20c282 379 packet->callback(packet, card, -ENODEV);
3038e353
KH
380}
381
382static void
383dummy_send_response(struct fw_card *card, struct fw_packet *packet)
384{
5e20c282 385 packet->callback(packet, card, -ENODEV);
3038e353
KH
386}
387
388static int
389dummy_enable_phys_dma(struct fw_card *card,
390 int node_id, int generation)
391{
392 return -ENODEV;
393}
394
395static struct fw_card_driver dummy_driver = {
5e20c282 396 .name = "dummy",
3038e353
KH
397 .enable = dummy_enable,
398 .update_phy_reg = dummy_update_phy_reg,
399 .set_config_rom = dummy_set_config_rom,
5e20c282
SR
400 .send_request = dummy_send_request,
401 .send_response = dummy_send_response,
5af4e5ea 402 .enable_phys_dma = dummy_enable_phys_dma,
3038e353
KH
403};
404
405void
406fw_core_remove_card(struct fw_card *card)
407{
408 card->driver->update_phy_reg(card, 4, 0x80 | 0x40, 0);
409 fw_core_initiate_bus_reset(card, 1);
410
411 down_write(&fw_bus_type.subsys.rwsem);
412 list_del(&card->link);
413 up_write(&fw_bus_type.subsys.rwsem);
414
415 /* Set up the dummy driver. */
416 card->driver = &dummy_driver;
417
418 fw_flush_transactions(card);
419
420 fw_destroy_nodes(card);
421
422 /* This also drops the subsystem reference. */
423 device_unregister(&card->card_device);
424}
425EXPORT_SYMBOL(fw_core_remove_card);
426
427struct fw_card *
428fw_card_get(struct fw_card *card)
429{
430 get_device(&card->card_device);
431
432 return card;
433}
434EXPORT_SYMBOL(fw_card_get);
435
436/* An assumption for fw_card_put() is that the card driver allocates
437 * the fw_card struct with kalloc and that it has been shut down
438 * before the last ref is dropped. */
439void
440fw_card_put(struct fw_card *card)
441{
442 put_device(&card->card_device);
443}
444EXPORT_SYMBOL(fw_card_put);
445
446int
447fw_core_initiate_bus_reset(struct fw_card *card, int short_reset)
448{
5e20c282 449 return card->driver->update_phy_reg(card, short_reset ? 5 : 1, 0, 0x40);
3038e353
KH
450}
451EXPORT_SYMBOL(fw_core_initiate_bus_reset);