ia64/linux-2.6.18-xen.hg

view drivers/ieee1394/csr.c @ 893:f994bfe9b93b

linux/blktap2: reduce TLB flush scope

c/s 885 added very coarse TLB flushing. Since these flushes always
follow single page updates, single page flushes (when available) are
sufficient.

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Jun 04 10:32:57 2009 +0100 (2009-06-04)
parents 831230e53067
children
line source
1 /*
2 * IEEE 1394 for Linux
3 *
4 * CSR implementation, iso/bus manager implementation.
5 *
6 * Copyright (C) 1999 Andreas E. Bombe
7 * 2002 Manfred Weihs <weihs@ict.tuwien.ac.at>
8 *
9 * This code is licensed under the GPL. See the file COPYING in the root
10 * directory of the kernel sources for details.
11 *
12 *
13 * Contributions:
14 *
15 * Manfred Weihs <weihs@ict.tuwien.ac.at>
16 * configuration ROM manipulation
17 *
18 */
20 #include <linux/string.h>
21 #include <linux/module.h>
22 #include <linux/moduleparam.h>
23 #include <linux/param.h>
24 #include <linux/spinlock.h>
26 #include "csr1212.h"
27 #include "ieee1394_types.h"
28 #include "hosts.h"
29 #include "ieee1394.h"
30 #include "highlevel.h"
31 #include "ieee1394_core.h"
33 /* Module Parameters */
34 /* this module parameter can be used to disable mapping of the FCP registers */
36 static int fcp = 1;
37 module_param(fcp, int, 0444);
38 MODULE_PARM_DESC(fcp, "Map FCP registers (default = 1, disable = 0).");
40 static struct csr1212_keyval *node_cap = NULL;
42 static void add_host(struct hpsb_host *host);
43 static void remove_host(struct hpsb_host *host);
44 static void host_reset(struct hpsb_host *host);
45 static int read_maps(struct hpsb_host *host, int nodeid, quadlet_t *buffer,
46 u64 addr, size_t length, u16 fl);
47 static int write_fcp(struct hpsb_host *host, int nodeid, int dest,
48 quadlet_t *data, u64 addr, size_t length, u16 flags);
49 static int read_regs(struct hpsb_host *host, int nodeid, quadlet_t *buf,
50 u64 addr, size_t length, u16 flags);
51 static int write_regs(struct hpsb_host *host, int nodeid, int destid,
52 quadlet_t *data, u64 addr, size_t length, u16 flags);
53 static int lock_regs(struct hpsb_host *host, int nodeid, quadlet_t *store,
54 u64 addr, quadlet_t data, quadlet_t arg, int extcode, u16 fl);
55 static int lock64_regs(struct hpsb_host *host, int nodeid, octlet_t * store,
56 u64 addr, octlet_t data, octlet_t arg, int extcode, u16 fl);
57 static int read_config_rom(struct hpsb_host *host, int nodeid, quadlet_t *buffer,
58 u64 addr, size_t length, u16 fl);
59 static u64 allocate_addr_range(u64 size, u32 alignment, void *__host);
60 static void release_addr_range(u64 addr, void *__host);
62 static struct hpsb_highlevel csr_highlevel = {
63 .name = "standard registers",
64 .add_host = add_host,
65 .remove_host = remove_host,
66 .host_reset = host_reset,
67 };
69 static struct hpsb_address_ops map_ops = {
70 .read = read_maps,
71 };
73 static struct hpsb_address_ops fcp_ops = {
74 .write = write_fcp,
75 };
77 static struct hpsb_address_ops reg_ops = {
78 .read = read_regs,
79 .write = write_regs,
80 .lock = lock_regs,
81 .lock64 = lock64_regs,
82 };
84 static struct hpsb_address_ops config_rom_ops = {
85 .read = read_config_rom,
86 };
88 struct csr1212_bus_ops csr_bus_ops = {
89 .allocate_addr_range = allocate_addr_range,
90 .release_addr = release_addr_range,
91 };
94 static u16 csr_crc16(unsigned *data, int length)
95 {
96 int check=0, i;
97 int shift, sum, next=0;
99 for (i = length; i; i--) {
100 for (next = check, shift = 28; shift >= 0; shift -= 4 ) {
101 sum = ((next >> 12) ^ (be32_to_cpu(*data) >> shift)) & 0xf;
102 next = (next << 4) ^ (sum << 12) ^ (sum << 5) ^ (sum);
103 }
104 check = next & 0xffff;
105 data++;
106 }
108 return check;
109 }
111 static void host_reset(struct hpsb_host *host)
112 {
113 host->csr.state &= 0x300;
115 host->csr.bus_manager_id = 0x3f;
116 host->csr.bandwidth_available = 4915;
117 host->csr.channels_available_hi = 0xfffffffe; /* pre-alloc ch 31 per 1394a-2000 */
118 host->csr.channels_available_lo = ~0;
119 host->csr.broadcast_channel = 0x80000000 | 31;
121 if (host->is_irm) {
122 if (host->driver->hw_csr_reg) {
123 host->driver->hw_csr_reg(host, 2, 0xfffffffe, ~0);
124 }
125 }
127 host->csr.node_ids = host->node_id << 16;
129 if (!host->is_root) {
130 /* clear cmstr bit */
131 host->csr.state &= ~0x100;
132 }
134 host->csr.topology_map[1] =
135 cpu_to_be32(be32_to_cpu(host->csr.topology_map[1]) + 1);
136 host->csr.topology_map[2] = cpu_to_be32(host->node_count << 16
137 | host->selfid_count);
138 host->csr.topology_map[0] =
139 cpu_to_be32((host->selfid_count + 2) << 16
140 | csr_crc16(host->csr.topology_map + 1,
141 host->selfid_count + 2));
143 host->csr.speed_map[1] =
144 cpu_to_be32(be32_to_cpu(host->csr.speed_map[1]) + 1);
145 host->csr.speed_map[0] = cpu_to_be32(0x3f1 << 16
146 | csr_crc16(host->csr.speed_map+1,
147 0x3f1));
148 }
150 /*
151 * HI == seconds (bits 0:2)
152 * LO == fraction units of 1/8000 of a second, as per 1394 (bits 19:31)
153 *
154 * Convert to units and then to HZ, for comparison to jiffies.
155 *
156 * By default this will end up being 800 units, or 100ms (125usec per
157 * unit).
158 *
159 * NOTE: The spec says 1/8000, but also says we can compute based on 1/8192
160 * like CSR specifies. Should make our math less complex.
161 */
162 static inline void calculate_expire(struct csr_control *csr)
163 {
164 unsigned long units;
166 /* Take the seconds, and convert to units */
167 units = (unsigned long)(csr->split_timeout_hi & 0x07) << 13;
169 /* Add in the fractional units */
170 units += (unsigned long)(csr->split_timeout_lo >> 19);
172 /* Convert to jiffies */
173 csr->expire = (unsigned long)(units * HZ) >> 13UL;
175 /* Just to keep from rounding low */
176 csr->expire++;
178 HPSB_VERBOSE("CSR: setting expire to %lu, HZ=%u", csr->expire, HZ);
179 }
182 static void add_host(struct hpsb_host *host)
183 {
184 struct csr1212_keyval *root;
185 quadlet_t bus_info[CSR_BUS_INFO_SIZE];
187 hpsb_register_addrspace(&csr_highlevel, host, &reg_ops,
188 CSR_REGISTER_BASE,
189 CSR_REGISTER_BASE + CSR_CONFIG_ROM);
190 hpsb_register_addrspace(&csr_highlevel, host, &config_rom_ops,
191 CSR_REGISTER_BASE + CSR_CONFIG_ROM,
192 CSR_REGISTER_BASE + CSR_CONFIG_ROM_END);
193 if (fcp) {
194 hpsb_register_addrspace(&csr_highlevel, host, &fcp_ops,
195 CSR_REGISTER_BASE + CSR_FCP_COMMAND,
196 CSR_REGISTER_BASE + CSR_FCP_END);
197 }
198 hpsb_register_addrspace(&csr_highlevel, host, &map_ops,
199 CSR_REGISTER_BASE + CSR_TOPOLOGY_MAP,
200 CSR_REGISTER_BASE + CSR_TOPOLOGY_MAP_END);
201 hpsb_register_addrspace(&csr_highlevel, host, &map_ops,
202 CSR_REGISTER_BASE + CSR_SPEED_MAP,
203 CSR_REGISTER_BASE + CSR_SPEED_MAP_END);
205 spin_lock_init(&host->csr.lock);
207 host->csr.state = 0;
208 host->csr.node_ids = 0;
209 host->csr.split_timeout_hi = 0;
210 host->csr.split_timeout_lo = 800 << 19;
211 calculate_expire(&host->csr);
212 host->csr.cycle_time = 0;
213 host->csr.bus_time = 0;
214 host->csr.bus_manager_id = 0x3f;
215 host->csr.bandwidth_available = 4915;
216 host->csr.channels_available_hi = 0xfffffffe; /* pre-alloc ch 31 per 1394a-2000 */
217 host->csr.channels_available_lo = ~0;
218 host->csr.broadcast_channel = 0x80000000 | 31;
220 if (host->is_irm) {
221 if (host->driver->hw_csr_reg) {
222 host->driver->hw_csr_reg(host, 2, 0xfffffffe, ~0);
223 }
224 }
226 if (host->csr.max_rec >= 9)
227 host->csr.max_rom = 2;
228 else if (host->csr.max_rec >= 5)
229 host->csr.max_rom = 1;
230 else
231 host->csr.max_rom = 0;
233 host->csr.generation = 2;
235 bus_info[1] = __constant_cpu_to_be32(0x31333934);
236 bus_info[2] = cpu_to_be32((hpsb_disable_irm ? 0 : 1 << CSR_IRMC_SHIFT) |
237 (1 << CSR_CMC_SHIFT) |
238 (1 << CSR_ISC_SHIFT) |
239 (0 << CSR_BMC_SHIFT) |
240 (0 << CSR_PMC_SHIFT) |
241 (host->csr.cyc_clk_acc << CSR_CYC_CLK_ACC_SHIFT) |
242 (host->csr.max_rec << CSR_MAX_REC_SHIFT) |
243 (host->csr.max_rom << CSR_MAX_ROM_SHIFT) |
244 (host->csr.generation << CSR_GENERATION_SHIFT) |
245 host->csr.lnk_spd);
247 bus_info[3] = cpu_to_be32(host->csr.guid_hi);
248 bus_info[4] = cpu_to_be32(host->csr.guid_lo);
250 /* The hardware copy of the bus info block will be set later when a
251 * bus reset is issued. */
253 csr1212_init_local_csr(host->csr.rom, bus_info, host->csr.max_rom);
255 root = host->csr.rom->root_kv;
257 if(csr1212_attach_keyval_to_directory(root, node_cap) != CSR1212_SUCCESS) {
258 HPSB_ERR("Failed to attach Node Capabilities to root directory");
259 }
261 host->update_config_rom = 1;
262 }
264 static void remove_host(struct hpsb_host *host)
265 {
266 quadlet_t bus_info[CSR_BUS_INFO_SIZE];
268 bus_info[1] = __constant_cpu_to_be32(0x31333934);
269 bus_info[2] = cpu_to_be32((0 << CSR_IRMC_SHIFT) |
270 (0 << CSR_CMC_SHIFT) |
271 (0 << CSR_ISC_SHIFT) |
272 (0 << CSR_BMC_SHIFT) |
273 (0 << CSR_PMC_SHIFT) |
274 (host->csr.cyc_clk_acc << CSR_CYC_CLK_ACC_SHIFT) |
275 (host->csr.max_rec << CSR_MAX_REC_SHIFT) |
276 (0 << CSR_MAX_ROM_SHIFT) |
277 (0 << CSR_GENERATION_SHIFT) |
278 host->csr.lnk_spd);
280 bus_info[3] = cpu_to_be32(host->csr.guid_hi);
281 bus_info[4] = cpu_to_be32(host->csr.guid_lo);
283 csr1212_detach_keyval_from_directory(host->csr.rom->root_kv, node_cap);
285 csr1212_init_local_csr(host->csr.rom, bus_info, 0);
286 host->update_config_rom = 1;
287 }
290 int hpsb_update_config_rom(struct hpsb_host *host, const quadlet_t *new_rom,
291 size_t buffersize, unsigned char rom_version)
292 {
293 unsigned long flags;
294 int ret;
296 HPSB_NOTICE("hpsb_update_config_rom() is deprecated");
298 spin_lock_irqsave(&host->csr.lock, flags);
299 if (rom_version != host->csr.generation)
300 ret = -1;
301 else if (buffersize > host->csr.rom->cache_head->size)
302 ret = -2;
303 else {
304 /* Just overwrite the generated ConfigROM image with new data,
305 * it can be regenerated later. */
306 memcpy(host->csr.rom->cache_head->data, new_rom, buffersize);
307 host->csr.rom->cache_head->len = buffersize;
309 if (host->driver->set_hw_config_rom)
310 host->driver->set_hw_config_rom(host, host->csr.rom->bus_info_data);
311 /* Increment the generation number to keep some sort of sync
312 * with the newer ConfigROM manipulation method. */
313 host->csr.generation++;
314 if (host->csr.generation > 0xf || host->csr.generation < 2)
315 host->csr.generation = 2;
316 ret=0;
317 }
318 spin_unlock_irqrestore(&host->csr.lock, flags);
319 return ret;
320 }
323 /* Read topology / speed maps and configuration ROM */
324 static int read_maps(struct hpsb_host *host, int nodeid, quadlet_t *buffer,
325 u64 addr, size_t length, u16 fl)
326 {
327 unsigned long flags;
328 int csraddr = addr - CSR_REGISTER_BASE;
329 const char *src;
331 spin_lock_irqsave(&host->csr.lock, flags);
333 if (csraddr < CSR_SPEED_MAP) {
334 src = ((char *)host->csr.topology_map) + csraddr
335 - CSR_TOPOLOGY_MAP;
336 } else {
337 src = ((char *)host->csr.speed_map) + csraddr - CSR_SPEED_MAP;
338 }
340 memcpy(buffer, src, length);
341 spin_unlock_irqrestore(&host->csr.lock, flags);
342 return RCODE_COMPLETE;
343 }
346 #define out if (--length == 0) break
348 static int read_regs(struct hpsb_host *host, int nodeid, quadlet_t *buf,
349 u64 addr, size_t length, u16 flags)
350 {
351 int csraddr = addr - CSR_REGISTER_BASE;
352 int oldcycle;
353 quadlet_t ret;
355 if ((csraddr | length) & 0x3)
356 return RCODE_TYPE_ERROR;
358 length /= 4;
360 switch (csraddr) {
361 case CSR_STATE_CLEAR:
362 *(buf++) = cpu_to_be32(host->csr.state);
363 out;
364 case CSR_STATE_SET:
365 *(buf++) = cpu_to_be32(host->csr.state);
366 out;
367 case CSR_NODE_IDS:
368 *(buf++) = cpu_to_be32(host->csr.node_ids);
369 out;
371 case CSR_RESET_START:
372 return RCODE_TYPE_ERROR;
374 /* address gap - handled by default below */
376 case CSR_SPLIT_TIMEOUT_HI:
377 *(buf++) = cpu_to_be32(host->csr.split_timeout_hi);
378 out;
379 case CSR_SPLIT_TIMEOUT_LO:
380 *(buf++) = cpu_to_be32(host->csr.split_timeout_lo);
381 out;
383 /* address gap */
384 return RCODE_ADDRESS_ERROR;
386 case CSR_CYCLE_TIME:
387 oldcycle = host->csr.cycle_time;
388 host->csr.cycle_time =
389 host->driver->devctl(host, GET_CYCLE_COUNTER, 0);
391 if (oldcycle > host->csr.cycle_time) {
392 /* cycle time wrapped around */
393 host->csr.bus_time += 1 << 7;
394 }
395 *(buf++) = cpu_to_be32(host->csr.cycle_time);
396 out;
397 case CSR_BUS_TIME:
398 oldcycle = host->csr.cycle_time;
399 host->csr.cycle_time =
400 host->driver->devctl(host, GET_CYCLE_COUNTER, 0);
402 if (oldcycle > host->csr.cycle_time) {
403 /* cycle time wrapped around */
404 host->csr.bus_time += (1 << 7);
405 }
406 *(buf++) = cpu_to_be32(host->csr.bus_time
407 | (host->csr.cycle_time >> 25));
408 out;
410 /* address gap */
411 return RCODE_ADDRESS_ERROR;
413 case CSR_BUSY_TIMEOUT:
414 /* not yet implemented */
415 return RCODE_ADDRESS_ERROR;
417 case CSR_BUS_MANAGER_ID:
418 if (host->driver->hw_csr_reg)
419 ret = host->driver->hw_csr_reg(host, 0, 0, 0);
420 else
421 ret = host->csr.bus_manager_id;
423 *(buf++) = cpu_to_be32(ret);
424 out;
425 case CSR_BANDWIDTH_AVAILABLE:
426 if (host->driver->hw_csr_reg)
427 ret = host->driver->hw_csr_reg(host, 1, 0, 0);
428 else
429 ret = host->csr.bandwidth_available;
431 *(buf++) = cpu_to_be32(ret);
432 out;
433 case CSR_CHANNELS_AVAILABLE_HI:
434 if (host->driver->hw_csr_reg)
435 ret = host->driver->hw_csr_reg(host, 2, 0, 0);
436 else
437 ret = host->csr.channels_available_hi;
439 *(buf++) = cpu_to_be32(ret);
440 out;
441 case CSR_CHANNELS_AVAILABLE_LO:
442 if (host->driver->hw_csr_reg)
443 ret = host->driver->hw_csr_reg(host, 3, 0, 0);
444 else
445 ret = host->csr.channels_available_lo;
447 *(buf++) = cpu_to_be32(ret);
448 out;
450 case CSR_BROADCAST_CHANNEL:
451 *(buf++) = cpu_to_be32(host->csr.broadcast_channel);
452 out;
454 /* address gap to end - fall through to default */
455 default:
456 return RCODE_ADDRESS_ERROR;
457 }
459 return RCODE_COMPLETE;
460 }
462 static int write_regs(struct hpsb_host *host, int nodeid, int destid,
463 quadlet_t *data, u64 addr, size_t length, u16 flags)
464 {
465 int csraddr = addr - CSR_REGISTER_BASE;
467 if ((csraddr | length) & 0x3)
468 return RCODE_TYPE_ERROR;
470 length /= 4;
472 switch (csraddr) {
473 case CSR_STATE_CLEAR:
474 /* FIXME FIXME FIXME */
475 printk("doh, someone wants to mess with state clear\n");
476 out;
477 case CSR_STATE_SET:
478 printk("doh, someone wants to mess with state set\n");
479 out;
481 case CSR_NODE_IDS:
482 host->csr.node_ids &= NODE_MASK << 16;
483 host->csr.node_ids |= be32_to_cpu(*(data++)) & (BUS_MASK << 16);
484 host->node_id = host->csr.node_ids >> 16;
485 host->driver->devctl(host, SET_BUS_ID, host->node_id >> 6);
486 out;
488 case CSR_RESET_START:
489 /* FIXME - perform command reset */
490 out;
492 /* address gap */
493 return RCODE_ADDRESS_ERROR;
495 case CSR_SPLIT_TIMEOUT_HI:
496 host->csr.split_timeout_hi =
497 be32_to_cpu(*(data++)) & 0x00000007;
498 calculate_expire(&host->csr);
499 out;
500 case CSR_SPLIT_TIMEOUT_LO:
501 host->csr.split_timeout_lo =
502 be32_to_cpu(*(data++)) & 0xfff80000;
503 calculate_expire(&host->csr);
504 out;
506 /* address gap */
507 return RCODE_ADDRESS_ERROR;
509 case CSR_CYCLE_TIME:
510 /* should only be set by cycle start packet, automatically */
511 host->csr.cycle_time = be32_to_cpu(*data);
512 host->driver->devctl(host, SET_CYCLE_COUNTER,
513 be32_to_cpu(*(data++)));
514 out;
515 case CSR_BUS_TIME:
516 host->csr.bus_time = be32_to_cpu(*(data++)) & 0xffffff80;
517 out;
519 /* address gap */
520 return RCODE_ADDRESS_ERROR;
522 case CSR_BUSY_TIMEOUT:
523 /* not yet implemented */
524 return RCODE_ADDRESS_ERROR;
526 case CSR_BUS_MANAGER_ID:
527 case CSR_BANDWIDTH_AVAILABLE:
528 case CSR_CHANNELS_AVAILABLE_HI:
529 case CSR_CHANNELS_AVAILABLE_LO:
530 /* these are not writable, only lockable */
531 return RCODE_TYPE_ERROR;
533 case CSR_BROADCAST_CHANNEL:
534 /* only the valid bit can be written */
535 host->csr.broadcast_channel = (host->csr.broadcast_channel & ~0x40000000)
536 | (be32_to_cpu(*data) & 0x40000000);
537 out;
539 /* address gap to end - fall through */
540 default:
541 return RCODE_ADDRESS_ERROR;
542 }
544 return RCODE_COMPLETE;
545 }
547 #undef out
550 static int lock_regs(struct hpsb_host *host, int nodeid, quadlet_t *store,
551 u64 addr, quadlet_t data, quadlet_t arg, int extcode, u16 fl)
552 {
553 int csraddr = addr - CSR_REGISTER_BASE;
554 unsigned long flags;
555 quadlet_t *regptr = NULL;
557 if (csraddr & 0x3)
558 return RCODE_TYPE_ERROR;
560 if (csraddr < CSR_BUS_MANAGER_ID || csraddr > CSR_CHANNELS_AVAILABLE_LO
561 || extcode != EXTCODE_COMPARE_SWAP)
562 goto unsupported_lockreq;
564 data = be32_to_cpu(data);
565 arg = be32_to_cpu(arg);
567 /* Is somebody releasing the broadcast_channel on us? */
568 if (csraddr == CSR_CHANNELS_AVAILABLE_HI && (data & 0x1)) {
569 /* Note: this is may not be the right way to handle
570 * the problem, so we should look into the proper way
571 * eventually. */
572 HPSB_WARN("Node [" NODE_BUS_FMT "] wants to release "
573 "broadcast channel 31. Ignoring.",
574 NODE_BUS_ARGS(host, nodeid));
576 data &= ~0x1; /* keep broadcast channel allocated */
577 }
579 if (host->driver->hw_csr_reg) {
580 quadlet_t old;
582 old = host->driver->
583 hw_csr_reg(host, (csraddr - CSR_BUS_MANAGER_ID) >> 2,
584 data, arg);
586 *store = cpu_to_be32(old);
587 return RCODE_COMPLETE;
588 }
590 spin_lock_irqsave(&host->csr.lock, flags);
592 switch (csraddr) {
593 case CSR_BUS_MANAGER_ID:
594 regptr = &host->csr.bus_manager_id;
595 *store = cpu_to_be32(*regptr);
596 if (*regptr == arg)
597 *regptr = data;
598 break;
600 case CSR_BANDWIDTH_AVAILABLE:
601 {
602 quadlet_t bandwidth;
603 quadlet_t old;
604 quadlet_t new;
606 regptr = &host->csr.bandwidth_available;
607 old = *regptr;
609 /* bandwidth available algorithm adapted from IEEE 1394a-2000 spec */
610 if (arg > 0x1fff) {
611 *store = cpu_to_be32(old); /* change nothing */
612 break;
613 }
614 data &= 0x1fff;
615 if (arg >= data) {
616 /* allocate bandwidth */
617 bandwidth = arg - data;
618 if (old >= bandwidth) {
619 new = old - bandwidth;
620 *store = cpu_to_be32(arg);
621 *regptr = new;
622 } else {
623 *store = cpu_to_be32(old);
624 }
625 } else {
626 /* deallocate bandwidth */
627 bandwidth = data - arg;
628 if (old + bandwidth < 0x2000) {
629 new = old + bandwidth;
630 *store = cpu_to_be32(arg);
631 *regptr = new;
632 } else {
633 *store = cpu_to_be32(old);
634 }
635 }
636 break;
637 }
639 case CSR_CHANNELS_AVAILABLE_HI:
640 {
641 /* Lock algorithm for CHANNELS_AVAILABLE as recommended by 1394a-2000 */
642 quadlet_t affected_channels = arg ^ data;
644 regptr = &host->csr.channels_available_hi;
646 if ((arg & affected_channels) == (*regptr & affected_channels)) {
647 *regptr ^= affected_channels;
648 *store = cpu_to_be32(arg);
649 } else {
650 *store = cpu_to_be32(*regptr);
651 }
653 break;
654 }
656 case CSR_CHANNELS_AVAILABLE_LO:
657 {
658 /* Lock algorithm for CHANNELS_AVAILABLE as recommended by 1394a-2000 */
659 quadlet_t affected_channels = arg ^ data;
661 regptr = &host->csr.channels_available_lo;
663 if ((arg & affected_channels) == (*regptr & affected_channels)) {
664 *regptr ^= affected_channels;
665 *store = cpu_to_be32(arg);
666 } else {
667 *store = cpu_to_be32(*regptr);
668 }
669 break;
670 }
671 }
673 spin_unlock_irqrestore(&host->csr.lock, flags);
675 return RCODE_COMPLETE;
677 unsupported_lockreq:
678 switch (csraddr) {
679 case CSR_STATE_CLEAR:
680 case CSR_STATE_SET:
681 case CSR_RESET_START:
682 case CSR_NODE_IDS:
683 case CSR_SPLIT_TIMEOUT_HI:
684 case CSR_SPLIT_TIMEOUT_LO:
685 case CSR_CYCLE_TIME:
686 case CSR_BUS_TIME:
687 case CSR_BROADCAST_CHANNEL:
688 return RCODE_TYPE_ERROR;
690 case CSR_BUSY_TIMEOUT:
691 /* not yet implemented - fall through */
692 default:
693 return RCODE_ADDRESS_ERROR;
694 }
695 }
697 static int lock64_regs(struct hpsb_host *host, int nodeid, octlet_t * store,
698 u64 addr, octlet_t data, octlet_t arg, int extcode, u16 fl)
699 {
700 int csraddr = addr - CSR_REGISTER_BASE;
701 unsigned long flags;
703 data = be64_to_cpu(data);
704 arg = be64_to_cpu(arg);
706 if (csraddr & 0x3)
707 return RCODE_TYPE_ERROR;
709 if (csraddr != CSR_CHANNELS_AVAILABLE
710 || extcode != EXTCODE_COMPARE_SWAP)
711 goto unsupported_lock64req;
713 /* Is somebody releasing the broadcast_channel on us? */
714 if (csraddr == CSR_CHANNELS_AVAILABLE_HI && (data & 0x100000000ULL)) {
715 /* Note: this is may not be the right way to handle
716 * the problem, so we should look into the proper way
717 * eventually. */
718 HPSB_WARN("Node [" NODE_BUS_FMT "] wants to release "
719 "broadcast channel 31. Ignoring.",
720 NODE_BUS_ARGS(host, nodeid));
722 data &= ~0x100000000ULL; /* keep broadcast channel allocated */
723 }
725 if (host->driver->hw_csr_reg) {
726 quadlet_t data_hi, data_lo;
727 quadlet_t arg_hi, arg_lo;
728 quadlet_t old_hi, old_lo;
730 data_hi = data >> 32;
731 data_lo = data & 0xFFFFFFFF;
732 arg_hi = arg >> 32;
733 arg_lo = arg & 0xFFFFFFFF;
735 old_hi = host->driver->hw_csr_reg(host, (csraddr - CSR_BUS_MANAGER_ID) >> 2,
736 data_hi, arg_hi);
738 old_lo = host->driver->hw_csr_reg(host, ((csraddr + 4) - CSR_BUS_MANAGER_ID) >> 2,
739 data_lo, arg_lo);
741 *store = cpu_to_be64(((octlet_t)old_hi << 32) | old_lo);
742 } else {
743 octlet_t old;
744 octlet_t affected_channels = arg ^ data;
746 spin_lock_irqsave(&host->csr.lock, flags);
748 old = ((octlet_t)host->csr.channels_available_hi << 32) | host->csr.channels_available_lo;
750 if ((arg & affected_channels) == (old & affected_channels)) {
751 host->csr.channels_available_hi ^= (affected_channels >> 32);
752 host->csr.channels_available_lo ^= (affected_channels & 0xffffffff);
753 *store = cpu_to_be64(arg);
754 } else {
755 *store = cpu_to_be64(old);
756 }
758 spin_unlock_irqrestore(&host->csr.lock, flags);
759 }
761 /* Is somebody erroneously releasing the broadcast_channel on us? */
762 if (host->csr.channels_available_hi & 0x1)
763 host->csr.channels_available_hi &= ~0x1;
765 return RCODE_COMPLETE;
767 unsupported_lock64req:
768 switch (csraddr) {
769 case CSR_STATE_CLEAR:
770 case CSR_STATE_SET:
771 case CSR_RESET_START:
772 case CSR_NODE_IDS:
773 case CSR_SPLIT_TIMEOUT_HI:
774 case CSR_SPLIT_TIMEOUT_LO:
775 case CSR_CYCLE_TIME:
776 case CSR_BUS_TIME:
777 case CSR_BUS_MANAGER_ID:
778 case CSR_BROADCAST_CHANNEL:
779 case CSR_BUSY_TIMEOUT:
780 case CSR_BANDWIDTH_AVAILABLE:
781 return RCODE_TYPE_ERROR;
783 default:
784 return RCODE_ADDRESS_ERROR;
785 }
786 }
788 static int write_fcp(struct hpsb_host *host, int nodeid, int dest,
789 quadlet_t *data, u64 addr, size_t length, u16 flags)
790 {
791 int csraddr = addr - CSR_REGISTER_BASE;
793 if (length > 512)
794 return RCODE_TYPE_ERROR;
796 switch (csraddr) {
797 case CSR_FCP_COMMAND:
798 highlevel_fcp_request(host, nodeid, 0, (u8 *)data, length);
799 break;
800 case CSR_FCP_RESPONSE:
801 highlevel_fcp_request(host, nodeid, 1, (u8 *)data, length);
802 break;
803 default:
804 return RCODE_TYPE_ERROR;
805 }
807 return RCODE_COMPLETE;
808 }
810 static int read_config_rom(struct hpsb_host *host, int nodeid, quadlet_t *buffer,
811 u64 addr, size_t length, u16 fl)
812 {
813 u32 offset = addr - CSR1212_REGISTER_SPACE_BASE;
815 if (csr1212_read(host->csr.rom, offset, buffer, length) == CSR1212_SUCCESS)
816 return RCODE_COMPLETE;
817 else
818 return RCODE_ADDRESS_ERROR;
819 }
821 static u64 allocate_addr_range(u64 size, u32 alignment, void *__host)
822 {
823 struct hpsb_host *host = (struct hpsb_host*)__host;
825 return hpsb_allocate_and_register_addrspace(&csr_highlevel,
826 host,
827 &config_rom_ops,
828 size, alignment,
829 CSR1212_UNITS_SPACE_BASE,
830 CSR1212_UNITS_SPACE_END);
831 }
833 static void release_addr_range(u64 addr, void *__host)
834 {
835 struct hpsb_host *host = (struct hpsb_host*)__host;
836 hpsb_unregister_addrspace(&csr_highlevel, host, addr);
837 }
840 int init_csr(void)
841 {
842 node_cap = csr1212_new_immediate(CSR1212_KV_ID_NODE_CAPABILITIES, 0x0083c0);
843 if (!node_cap) {
844 HPSB_ERR("Failed to allocate memory for Node Capabilties ConfigROM entry!");
845 return -ENOMEM;
846 }
848 hpsb_register_highlevel(&csr_highlevel);
850 return 0;
851 }
853 void cleanup_csr(void)
854 {
855 if (node_cap)
856 csr1212_release_keyval(node_cap);
857 hpsb_unregister_highlevel(&csr_highlevel);
858 }