4 * Copyright (C) 1999 Andreas E. Bombe
6 * This code is licensed under the GPL. See the file COPYING in the root
7 * directory of the kernel sources for details.
12 * Christian Toegel <christian.toegel@gmx.at>
13 * unregister address space
15 * Manfred Weihs <weihs@ict.tuwien.ac.at>
16 * unregister address space
20 #include <linux/config.h>
21 #include <linux/slab.h>
22 #include <linux/list.h>
23 #include <linux/bitops.h>
26 #include "ieee1394_types.h"
28 #include "ieee1394_core.h"
29 #include "highlevel.h"
34 struct list_head list
;
35 struct hpsb_host
*host
;
42 static LIST_HEAD(hl_drivers
);
43 static DECLARE_RWSEM(hl_drivers_sem
);
45 static LIST_HEAD(hl_irqs
);
46 static DEFINE_RWLOCK(hl_irqs_lock
);
48 static DEFINE_RWLOCK(addr_space_lock
);
50 /* addr_space list will have zero and max already included as bounds */
51 static struct hpsb_address_ops dummy_ops
= { NULL
, NULL
, NULL
, NULL
};
52 static struct hpsb_address_serve dummy_zero_addr
, dummy_max_addr
;
55 static struct hl_host_info
*hl_get_hostinfo(struct hpsb_highlevel
*hl
,
56 struct hpsb_host
*host
)
58 struct hl_host_info
*hi
= NULL
;
63 read_lock(&hl
->host_info_lock
);
64 list_for_each_entry(hi
, &hl
->host_info_list
, list
) {
65 if (hi
->host
== host
) {
66 read_unlock(&hl
->host_info_lock
);
70 read_unlock(&hl
->host_info_lock
);
76 /* Returns a per host/driver data structure that was previously stored by
77 * hpsb_create_hostinfo. */
78 void *hpsb_get_hostinfo(struct hpsb_highlevel
*hl
, struct hpsb_host
*host
)
80 struct hl_host_info
*hi
= hl_get_hostinfo(hl
, host
);
89 /* If size is zero, then the return here is only valid for error checking */
90 void *hpsb_create_hostinfo(struct hpsb_highlevel
*hl
, struct hpsb_host
*host
,
93 struct hl_host_info
*hi
;
97 hi
= hl_get_hostinfo(hl
, host
);
99 HPSB_ERR("%s called hpsb_create_hostinfo when hostinfo already exists",
104 hi
= kzalloc(sizeof(*hi
) + data_size
, GFP_ATOMIC
);
109 data
= hi
->data
= hi
+ 1;
110 hi
->size
= data_size
;
116 write_lock_irqsave(&hl
->host_info_lock
, flags
);
117 list_add_tail(&hi
->list
, &hl
->host_info_list
);
118 write_unlock_irqrestore(&hl
->host_info_lock
, flags
);
124 int hpsb_set_hostinfo(struct hpsb_highlevel
*hl
, struct hpsb_host
*host
,
127 struct hl_host_info
*hi
;
129 hi
= hl_get_hostinfo(hl
, host
);
131 if (!hi
->size
&& !hi
->data
) {
135 HPSB_ERR("%s called hpsb_set_hostinfo when hostinfo already has data",
138 HPSB_ERR("%s called hpsb_set_hostinfo when no hostinfo exists",
145 void hpsb_destroy_hostinfo(struct hpsb_highlevel
*hl
, struct hpsb_host
*host
)
147 struct hl_host_info
*hi
;
149 hi
= hl_get_hostinfo(hl
, host
);
152 write_lock_irqsave(&hl
->host_info_lock
, flags
);
154 write_unlock_irqrestore(&hl
->host_info_lock
, flags
);
162 void hpsb_set_hostinfo_key(struct hpsb_highlevel
*hl
, struct hpsb_host
*host
, unsigned long key
)
164 struct hl_host_info
*hi
;
166 hi
= hl_get_hostinfo(hl
, host
);
174 void *hpsb_get_hostinfo_bykey(struct hpsb_highlevel
*hl
, unsigned long key
)
176 struct hl_host_info
*hi
;
182 read_lock(&hl
->host_info_lock
);
183 list_for_each_entry(hi
, &hl
->host_info_list
, list
) {
184 if (hi
->key
== key
) {
189 read_unlock(&hl
->host_info_lock
);
195 static int highlevel_for_each_host_reg(struct hpsb_host
*host
, void *__data
)
197 struct hpsb_highlevel
*hl
= __data
;
201 if (host
->update_config_rom
) {
202 if (hpsb_update_config_rom_image(host
) < 0) {
203 HPSB_ERR("Failed to generate Configuration ROM image for host "
204 "%s-%d", hl
->name
, host
->id
);
211 void hpsb_register_highlevel(struct hpsb_highlevel
*hl
)
215 INIT_LIST_HEAD(&hl
->addr_list
);
216 INIT_LIST_HEAD(&hl
->host_info_list
);
218 rwlock_init(&hl
->host_info_lock
);
220 down_write(&hl_drivers_sem
);
221 list_add_tail(&hl
->hl_list
, &hl_drivers
);
222 up_write(&hl_drivers_sem
);
224 write_lock_irqsave(&hl_irqs_lock
, flags
);
225 list_add_tail(&hl
->irq_list
, &hl_irqs
);
226 write_unlock_irqrestore(&hl_irqs_lock
, flags
);
229 nodemgr_for_each_host(hl
, highlevel_for_each_host_reg
);
234 static void __delete_addr(struct hpsb_address_serve
*as
)
236 list_del(&as
->host_list
);
237 list_del(&as
->hl_list
);
241 static void __unregister_host(struct hpsb_highlevel
*hl
, struct hpsb_host
*host
, int update_cr
)
244 struct list_head
*lh
, *next
;
245 struct hpsb_address_serve
*as
;
247 /* First, let the highlevel driver unreg */
249 hl
->remove_host(host
);
251 /* Remove any addresses that are matched for this highlevel driver
252 * and this particular host. */
253 write_lock_irqsave(&addr_space_lock
, flags
);
254 list_for_each_safe (lh
, next
, &hl
->addr_list
) {
255 as
= list_entry(lh
, struct hpsb_address_serve
, hl_list
);
257 if (as
->host
== host
)
260 write_unlock_irqrestore(&addr_space_lock
, flags
);
262 /* Now update the config-rom to reflect anything removed by the
263 * highlevel driver. */
264 if (update_cr
&& host
->update_config_rom
) {
265 if (hpsb_update_config_rom_image(host
) < 0) {
266 HPSB_ERR("Failed to generate Configuration ROM image for host "
267 "%s-%d", hl
->name
, host
->id
);
271 /* And finally, remove all the host info associated between these
273 hpsb_destroy_hostinfo(hl
, host
);
276 static int highlevel_for_each_host_unreg(struct hpsb_host
*host
, void *__data
)
278 struct hpsb_highlevel
*hl
= __data
;
280 __unregister_host(hl
, host
, 1);
285 void hpsb_unregister_highlevel(struct hpsb_highlevel
*hl
)
289 write_lock_irqsave(&hl_irqs_lock
, flags
);
290 list_del(&hl
->irq_list
);
291 write_unlock_irqrestore(&hl_irqs_lock
, flags
);
293 down_write(&hl_drivers_sem
);
294 list_del(&hl
->hl_list
);
295 up_write(&hl_drivers_sem
);
297 nodemgr_for_each_host(hl
, highlevel_for_each_host_unreg
);
300 u64
hpsb_allocate_and_register_addrspace(struct hpsb_highlevel
*hl
,
301 struct hpsb_host
*host
,
302 struct hpsb_address_ops
*ops
,
303 u64 size
, u64 alignment
,
306 struct hpsb_address_serve
*as
, *a1
, *a2
;
307 struct list_head
*entry
;
308 u64 retval
= CSR1212_INVALID_ADDR_SPACE
;
310 u64 align_mask
= ~(alignment
- 1);
312 if ((alignment
& 3) || (alignment
> 0x800000000000ULL
) ||
313 (hweight64(alignment
) != 1)) {
314 HPSB_ERR("%s called with invalid alignment: 0x%048llx",
315 __FUNCTION__
, (unsigned long long)alignment
);
320 * avoids controller's posted write area (see OHCI 1.1 clause 1.5) */
321 if (start
== CSR1212_INVALID_ADDR_SPACE
&&
322 end
== CSR1212_INVALID_ADDR_SPACE
) {
323 start
= host
->middle_addr_space
;
324 end
= CSR1212_ALL_SPACE_END
;
327 if (((start
|end
) & ~align_mask
) || (start
>= end
) || (end
> 0x1000000000000ULL
)) {
328 HPSB_ERR("%s called with invalid addresses (start = %012Lx end = %012Lx)",
329 __FUNCTION__
, (unsigned long long)start
, (unsigned long long)end
);
333 as
= kmalloc(sizeof(*as
), GFP_KERNEL
);
337 INIT_LIST_HEAD(&as
->host_list
);
338 INIT_LIST_HEAD(&as
->hl_list
);
342 write_lock_irqsave(&addr_space_lock
, flags
);
344 list_for_each(entry
, &host
->addr_space
) {
348 a1
= list_entry(entry
, struct hpsb_address_serve
, host_list
);
349 a2
= list_entry(entry
->next
, struct hpsb_address_serve
, host_list
);
351 a1sa
= a1
->start
& align_mask
;
352 a1ea
= (a1
->end
+ alignment
-1) & align_mask
;
353 a2sa
= a2
->start
& align_mask
;
354 a2ea
= (a2
->end
+ alignment
-1) & align_mask
;
356 if ((a2sa
- a1ea
>= size
) && (a2sa
- start
>= size
) && (a2sa
> start
)) {
357 as
->start
= max(start
, a1ea
);
358 as
->end
= as
->start
+ size
;
359 list_add(&as
->host_list
, entry
);
360 list_add_tail(&as
->hl_list
, &hl
->addr_list
);
366 write_unlock_irqrestore(&addr_space_lock
, flags
);
368 if (retval
== CSR1212_INVALID_ADDR_SPACE
) {
375 int hpsb_register_addrspace(struct hpsb_highlevel
*hl
, struct hpsb_host
*host
,
376 struct hpsb_address_ops
*ops
, u64 start
, u64 end
)
378 struct hpsb_address_serve
*as
;
379 struct list_head
*lh
;
383 if (((start
|end
) & 3) || (start
>= end
) || (end
> 0x1000000000000ULL
)) {
384 HPSB_ERR("%s called with invalid addresses", __FUNCTION__
);
388 as
= kmalloc(sizeof(*as
), GFP_ATOMIC
);
392 INIT_LIST_HEAD(&as
->host_list
);
393 INIT_LIST_HEAD(&as
->hl_list
);
399 write_lock_irqsave(&addr_space_lock
, flags
);
401 list_for_each(lh
, &host
->addr_space
) {
402 struct hpsb_address_serve
*as_this
=
403 list_entry(lh
, struct hpsb_address_serve
, host_list
);
404 struct hpsb_address_serve
*as_next
=
405 list_entry(lh
->next
, struct hpsb_address_serve
, host_list
);
407 if (as_this
->end
> as
->start
)
410 if (as_next
->start
>= as
->end
) {
411 list_add(&as
->host_list
, lh
);
412 list_add_tail(&as
->hl_list
, &hl
->addr_list
);
417 write_unlock_irqrestore(&addr_space_lock
, flags
);
425 int hpsb_unregister_addrspace(struct hpsb_highlevel
*hl
, struct hpsb_host
*host
,
429 struct hpsb_address_serve
*as
;
430 struct list_head
*lh
, *next
;
433 write_lock_irqsave(&addr_space_lock
, flags
);
435 list_for_each_safe (lh
, next
, &hl
->addr_list
) {
436 as
= list_entry(lh
, struct hpsb_address_serve
, hl_list
);
437 if (as
->start
== start
&& as
->host
== host
) {
444 write_unlock_irqrestore(&addr_space_lock
, flags
);
449 int hpsb_listen_channel(struct hpsb_highlevel
*hl
, struct hpsb_host
*host
,
450 unsigned int channel
)
453 HPSB_ERR("%s called with invalid channel", __FUNCTION__
);
457 if (host
->iso_listen_count
[channel
]++ == 0) {
458 return host
->driver
->devctl(host
, ISO_LISTEN_CHANNEL
, channel
);
464 void hpsb_unlisten_channel(struct hpsb_highlevel
*hl
, struct hpsb_host
*host
,
465 unsigned int channel
)
468 HPSB_ERR("%s called with invalid channel", __FUNCTION__
);
472 if (--host
->iso_listen_count
[channel
] == 0) {
473 host
->driver
->devctl(host
, ISO_UNLISTEN_CHANNEL
, channel
);
477 static void init_hpsb_highlevel(struct hpsb_host
*host
)
479 INIT_LIST_HEAD(&dummy_zero_addr
.host_list
);
480 INIT_LIST_HEAD(&dummy_zero_addr
.hl_list
);
481 INIT_LIST_HEAD(&dummy_max_addr
.host_list
);
482 INIT_LIST_HEAD(&dummy_max_addr
.hl_list
);
484 dummy_zero_addr
.op
= dummy_max_addr
.op
= &dummy_ops
;
486 dummy_zero_addr
.start
= dummy_zero_addr
.end
= 0;
487 dummy_max_addr
.start
= dummy_max_addr
.end
= ((u64
) 1) << 48;
489 list_add_tail(&dummy_zero_addr
.host_list
, &host
->addr_space
);
490 list_add_tail(&dummy_max_addr
.host_list
, &host
->addr_space
);
493 void highlevel_add_host(struct hpsb_host
*host
)
495 struct hpsb_highlevel
*hl
;
497 init_hpsb_highlevel(host
);
499 down_read(&hl_drivers_sem
);
500 list_for_each_entry(hl
, &hl_drivers
, hl_list
) {
504 up_read(&hl_drivers_sem
);
505 if (host
->update_config_rom
) {
506 if (hpsb_update_config_rom_image(host
) < 0)
507 HPSB_ERR("Failed to generate Configuration ROM image for "
508 "host %s-%d", hl
->name
, host
->id
);
512 void highlevel_remove_host(struct hpsb_host
*host
)
514 struct hpsb_highlevel
*hl
;
516 down_read(&hl_drivers_sem
);
517 list_for_each_entry(hl
, &hl_drivers
, hl_list
)
518 __unregister_host(hl
, host
, 0);
519 up_read(&hl_drivers_sem
);
522 void highlevel_host_reset(struct hpsb_host
*host
)
525 struct hpsb_highlevel
*hl
;
527 read_lock_irqsave(&hl_irqs_lock
, flags
);
528 list_for_each_entry(hl
, &hl_irqs
, irq_list
) {
530 hl
->host_reset(host
);
532 read_unlock_irqrestore(&hl_irqs_lock
, flags
);
535 void highlevel_iso_receive(struct hpsb_host
*host
, void *data
, size_t length
)
538 struct hpsb_highlevel
*hl
;
539 int channel
= (((quadlet_t
*)data
)[0] >> 8) & 0x3f;
541 read_lock_irqsave(&hl_irqs_lock
, flags
);
542 list_for_each_entry(hl
, &hl_irqs
, irq_list
) {
544 hl
->iso_receive(host
, channel
, data
, length
);
546 read_unlock_irqrestore(&hl_irqs_lock
, flags
);
549 void highlevel_fcp_request(struct hpsb_host
*host
, int nodeid
, int direction
,
550 void *data
, size_t length
)
553 struct hpsb_highlevel
*hl
;
554 int cts
= ((quadlet_t
*)data
)[0] >> 4;
556 read_lock_irqsave(&hl_irqs_lock
, flags
);
557 list_for_each_entry(hl
, &hl_irqs
, irq_list
) {
559 hl
->fcp_request(host
, nodeid
, direction
, cts
, data
,
562 read_unlock_irqrestore(&hl_irqs_lock
, flags
);
565 int highlevel_read(struct hpsb_host
*host
, int nodeid
, void *data
,
566 u64 addr
, unsigned int length
, u16 flags
)
568 struct hpsb_address_serve
*as
;
569 unsigned int partlength
;
570 int rcode
= RCODE_ADDRESS_ERROR
;
572 read_lock(&addr_space_lock
);
574 list_for_each_entry(as
, &host
->addr_space
, host_list
) {
575 if (as
->start
> addr
)
578 if (as
->end
> addr
) {
579 partlength
= min(as
->end
- addr
, (u64
) length
);
582 rcode
= as
->op
->read(host
, nodeid
, data
,
583 addr
, partlength
, flags
);
585 rcode
= RCODE_TYPE_ERROR
;
589 length
-= partlength
;
592 if ((rcode
!= RCODE_COMPLETE
) || !length
) {
598 read_unlock(&addr_space_lock
);
600 if (length
&& (rcode
== RCODE_COMPLETE
)) {
601 rcode
= RCODE_ADDRESS_ERROR
;
607 int highlevel_write(struct hpsb_host
*host
, int nodeid
, int destid
,
608 void *data
, u64 addr
, unsigned int length
, u16 flags
)
610 struct hpsb_address_serve
*as
;
611 unsigned int partlength
;
612 int rcode
= RCODE_ADDRESS_ERROR
;
614 read_lock(&addr_space_lock
);
616 list_for_each_entry(as
, &host
->addr_space
, host_list
) {
617 if (as
->start
> addr
)
620 if (as
->end
> addr
) {
621 partlength
= min(as
->end
- addr
, (u64
) length
);
624 rcode
= as
->op
->write(host
, nodeid
, destid
,
625 data
, addr
, partlength
, flags
);
627 rcode
= RCODE_TYPE_ERROR
;
631 length
-= partlength
;
634 if ((rcode
!= RCODE_COMPLETE
) || !length
) {
640 read_unlock(&addr_space_lock
);
642 if (length
&& (rcode
== RCODE_COMPLETE
)) {
643 rcode
= RCODE_ADDRESS_ERROR
;
650 int highlevel_lock(struct hpsb_host
*host
, int nodeid
, quadlet_t
*store
,
651 u64 addr
, quadlet_t data
, quadlet_t arg
, int ext_tcode
, u16 flags
)
653 struct hpsb_address_serve
*as
;
654 int rcode
= RCODE_ADDRESS_ERROR
;
656 read_lock(&addr_space_lock
);
658 list_for_each_entry(as
, &host
->addr_space
, host_list
) {
659 if (as
->start
> addr
)
662 if (as
->end
> addr
) {
664 rcode
= as
->op
->lock(host
, nodeid
, store
, addr
,
665 data
, arg
, ext_tcode
, flags
);
667 rcode
= RCODE_TYPE_ERROR
;
674 read_unlock(&addr_space_lock
);
679 int highlevel_lock64(struct hpsb_host
*host
, int nodeid
, octlet_t
*store
,
680 u64 addr
, octlet_t data
, octlet_t arg
, int ext_tcode
, u16 flags
)
682 struct hpsb_address_serve
*as
;
683 int rcode
= RCODE_ADDRESS_ERROR
;
685 read_lock(&addr_space_lock
);
687 list_for_each_entry(as
, &host
->addr_space
, host_list
) {
688 if (as
->start
> addr
)
691 if (as
->end
> addr
) {
692 if (as
->op
->lock64
) {
693 rcode
= as
->op
->lock64(host
, nodeid
, store
,
697 rcode
= RCODE_TYPE_ERROR
;
704 read_unlock(&addr_space_lock
);