* Re: [Bugme-new] [Bug 33042] New: Marvell 88E1145 phy configured incorrectly in fiber mode
From: Alex Dubov @ 2011-04-18 5:44 UTC (permalink / raw)
To: Andy Fleming
Cc: Andrew Morton, David Daney, netdev, bugzilla-daemon, bugme-daemon,
Grant Likely
In-Reply-To: <BANLkTikJ60ND7s5-jfGTBDG3BoM-294CSA@mail.gmail.com>
> > --- On Thu, 14/4/11, Andy Fleming <afleming@gmail.com>
> wrote:
> >
> >>
> >
> > The u-boot is standard stock u-boot pulled from the
> recent git,
> > no special configuration involved.
>
>
> Are you seeing this message when you run ethernet in
> u-boot?
>
> "Speed: 1000, full duplex, fiber mode"
I have this weird problem whereupon I assume something and then keep
believing it's true. So not, I'm not seeing this message. :)
There are two interfaces attached to that phy, one is normal RJ45, the
other is an uTCA backplane (it has only two pairs, so I assumed it must
be operating in fiber mode). Uboot works perfectly well with both and
prints the same messages.
That's the example printout from u-boot (eTSEC1 is connected to backplane)
> dhcp
Speed: 1000, full duplex
BOOTP broadcast 1
DHCP client bound to address 192.168.1.202
Using eTSEC1 device
>
> You could probably change to use a fixed link by removing
> the
> phy-handle property from your ethernet device node, and
> adding:
> "fixed-link=<0 1000 1 0 0>". If that works,
> then the issue is that
> Linux is breaking something when it connects. It might be
> good enough
> for you to use fixed-link, though it would be good to
> actually find
> out what's going wrong with the PHY driver.
>
I'll try this out now.
I'm trying to obtain a data sheet for the device, but had not succeeded
in it just yet.
^ permalink raw reply
* Re: [PATCH net-next-2.6 0/3] new SCTP sockets APIs
From: David Miller @ 2011-04-18 4:09 UTC (permalink / raw)
To: yjwei; +Cc: shanwei, vladislav.yasevich, netdev, linux-sctp
In-Reply-To: <4DABB905.70902@cn.fujitsu.com>
From: Wei Yongjun <yjwei@cn.fujitsu.com>
Date: Mon, 18 Apr 2011 12:07:33 +0800
> If Vlad is allowed, I can help him to push all of those patchs(or
> part of them) to net-next-2.6 tree by many small patchsets. most of
> those patch have been waited for about one year.
If someone would process this backlog, yes that would be great.
No patch should wait so long to get integrated. If Vlad's time is
really so limited, he should pass maintainership over to someone
who is capable and active.
^ permalink raw reply
* Re: [PATCH net-next-2.6 0/3] new SCTP sockets APIs
From: Wei Yongjun @ 2011-04-18 4:07 UTC (permalink / raw)
To: Shan Wei; +Cc: David Miller, Vlad Yasevich, netdev@vger.kernel.org, lksctp
In-Reply-To: <4DABB43B.9010204@cn.fujitsu.com>
> To David, Vlad:
>
> There are many patches in vlad's net-next(1*) tree besides these three ones.
> Maybe vlad is busy doing other things, Should we need to respin these patches
> base on latest kernel and submit to you? So we can do further work against latest kernel.
>
> 1*: vlad's net-next tree:
> http://git.kernel.org/?p=linux/kernel/git/vxy/lksctp-dev.git;a=shortlog;h=refs/heads/net-next
If Vlad is allowed, I can help him to push all of those patchs(or part of them) to
net-next-2.6 tree by many small patchsets.
most of those patch have been waited for about one year.
>
> Wei Yongjun wrote, at 04/18/2011 11:24 AM:
>> This patchset implement some new sockets APIs for net-next-2.6.
>>
>> Wei Yongjun (3):
>> sctp: implement socket option SCTP_GET_ASSOC_ID_LIST
>> sctp: change auth event type name to SCTP_AUTHENTICATION_EVENT
>> sctp: implement event notification SCTP_SENDER_DRY_EVENT
>>
>> include/net/sctp/sm.h | 1 +
>> include/net/sctp/ulpevent.h | 3 ++
>> include/net/sctp/user.h | 33 ++++++++++++++++++++++++++-
>> net/sctp/sm_statefuns.c | 24 +++++++++++++++++++
>> net/sctp/sm_statetable.c | 2 +-
>> net/sctp/socket.c | 52 +++++++++++++++++++++++++++++++++++++++++++
>> net/sctp/ulpevent.c | 30 ++++++++++++++++++++++++-
>> 7 files changed, 142 insertions(+), 3 deletions(-)
>>
>>
>> --
>> To unsubscribe from this list: send the line "unsubscribe linux-sctp" in
>> the body of a message to majordomo@vger.kernel.org
>> More majordomo info at http://vger.kernel.org/majordomo-info.html
>>
>
^ permalink raw reply
* Re: [PATCH net-next-2.6 0/3] new SCTP sockets APIs
From: Shan Wei @ 2011-04-18 3:47 UTC (permalink / raw)
To: Wei Yongjun, David Miller, Vlad Yasevich; +Cc: netdev@vger.kernel.org, lksctp
In-Reply-To: <4DABAEF1.1010506@cn.fujitsu.com>
To David, Vlad:
There are many patches in vlad's net-next(1*) tree besides these three ones.
Maybe vlad is busy doing other things, Should we need to respin these patches
base on latest kernel and submit to you? So we can do further work against latest kernel.
1*: vlad's net-next tree:
http://git.kernel.org/?p=linux/kernel/git/vxy/lksctp-dev.git;a=shortlog;h=refs/heads/net-next
Wei Yongjun wrote, at 04/18/2011 11:24 AM:
> This patchset implement some new sockets APIs for net-next-2.6.
>
> Wei Yongjun (3):
> sctp: implement socket option SCTP_GET_ASSOC_ID_LIST
> sctp: change auth event type name to SCTP_AUTHENTICATION_EVENT
> sctp: implement event notification SCTP_SENDER_DRY_EVENT
>
> include/net/sctp/sm.h | 1 +
> include/net/sctp/ulpevent.h | 3 ++
> include/net/sctp/user.h | 33 ++++++++++++++++++++++++++-
> net/sctp/sm_statefuns.c | 24 +++++++++++++++++++
> net/sctp/sm_statetable.c | 2 +-
> net/sctp/socket.c | 52 +++++++++++++++++++++++++++++++++++++++++++
> net/sctp/ulpevent.c | 30 ++++++++++++++++++++++++-
> 7 files changed, 142 insertions(+), 3 deletions(-)
>
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-sctp" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
>
--
Best Regards
-----
Shan Wei
^ permalink raw reply
* Re: [PATCH 6/42] decnet: Fix set-but-unused variable.
From: David Miller @ 2011-04-18 3:48 UTC (permalink / raw)
To: bhutchings; +Cc: netdev
In-Reply-To: <1303092729.5282.1005.camel@localhost>
From: Ben Hutchings <bhutchings@solarflare.com>
Date: Mon, 18 Apr 2011 03:12:09 +0100
> On Sun, 2011-04-17 at 17:32 -0700, David Miller wrote:
>> "next" in dn_rebuild_zone() is set but not actually used,
>> kill it off.
>>
>> Signed-off-by: David S. Miller <davem@davemloft.net>
>> ---
>> net/decnet/dn_table.c | 3 +--
>> 1 files changed, 1 insertions(+), 2 deletions(-)
>>
>> diff --git a/net/decnet/dn_table.c b/net/decnet/dn_table.c
>> index 99d8d3a..d8ea583 100644
>> --- a/net/decnet/dn_table.c
>> +++ b/net/decnet/dn_table.c
>> @@ -124,11 +124,10 @@ static inline void dn_rebuild_zone(struct dn_zone *dz,
>> int old_divisor)
>> {
>> int i;
>> - struct dn_fib_node *f, **fp, *next;
>> + struct dn_fib_node *f, **fp;
>>
>> for(i = 0; i < old_divisor; i++) {
>> for(f = old_ht[i]; f; f = f->fn_next) {
>> - next = f->fn_next;
>> for(fp = dn_chain_p(f->fn_key, dz);
>> *fp && dn_key_leq((*fp)->fn_key, f->fn_key);
>> fp = &(*fp)->fn_next)
>
> This function is rebuilding a hash table after the number of buckets is
> changed. After moving each element into a new bucket, it needs to carry
> on iterating over the old bucket. Therefore the 'next' variable is
> really needed and the second for-loop should use it: 'f = next', not
> 'f = f->fn_next'.
Good catch, I committed the following:
--------------------
decnet: Don't leak entries when rebuilding zone.
As noticed by Ben Hutchings, when we move entries from
one table to another we leak all except the first entry.
Put back the "next" variable removed by commit
9bf9055eb716f85372c41b3fbc51f90bc7653740 ("decnet: Fix set-but-unused
variable.") and use it properly.
Reported-by: Ben Hutchings <bhutchings@solarflare.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
---
net/decnet/dn_table.c | 5 +++--
1 files changed, 3 insertions(+), 2 deletions(-)
diff --git a/net/decnet/dn_table.c b/net/decnet/dn_table.c
index d8ea583..bd0a52d 100644
--- a/net/decnet/dn_table.c
+++ b/net/decnet/dn_table.c
@@ -123,11 +123,12 @@ static inline void dn_rebuild_zone(struct dn_zone *dz,
struct dn_fib_node **old_ht,
int old_divisor)
{
+ struct dn_fib_node *f, **fp, *next;
int i;
- struct dn_fib_node *f, **fp;
for(i = 0; i < old_divisor; i++) {
- for(f = old_ht[i]; f; f = f->fn_next) {
+ for(f = old_ht[i]; f; f = next) {
+ next = f->fn_next;
for(fp = dn_chain_p(f->fn_key, dz);
*fp && dn_key_leq((*fp)->fn_key, f->fn_key);
fp = &(*fp)->fn_next)
--
1.7.4.3
^ permalink raw reply related
* Re: [PATCH 0/42] Kill -Wunused-but-set warnings
From: David Miller @ 2011-04-18 3:38 UTC (permalink / raw)
To: bhutchings; +Cc: netdev
In-Reply-To: <1303093155.5282.1009.camel@localhost>
From: Ben Hutchings <bhutchings@solarflare.com>
Date: Mon, 18 Apr 2011 03:19:15 +0100
> In most of these cases there is presumably no need for the variable at
> all. In others, the variable should have been used - which I believe is
> the main reason for the warning - and by removing it you will be hiding
> a bug.
If you look at about 5 or 6 of my patches, that's exactly what I did,
make use of the variable.
Otherwise I tossed it.
It seems I messed up the decnet case, which I'll fix shortly.
^ permalink raw reply
* [PATCH net-next-2.6 3/3] sctp: implement event notification SCTP_SENDER_DRY_EVENT
From: Wei Yongjun @ 2011-04-18 3:29 UTC (permalink / raw)
To: David Miller; +Cc: netdev@vger.kernel.org, lksctp
In-Reply-To: <4DABAEF1.1010506@cn.fujitsu.com>
This patch implement event notification SCTP_SENDER_DRY_EVENT.
SCTP Socket API Extensions:
6.1.9. SCTP_SENDER_DRY_EVENT
When the SCTP stack has no more user data to send or retransmit, this
notification is given to the user. Also, at the time when a user app
subscribes to this event, if there is no data to be sent or
retransmit, the stack will immediately send up this notification.
Signed-off-by: Wei Yongjun <yjwei@cn.fujitsu.com>
Signed-off-by: Vlad Yasevich <vladislav.yasevich@hp.com>
---
include/net/sctp/sm.h | 1 +
include/net/sctp/ulpevent.h | 3 +++
include/net/sctp/user.h | 17 +++++++++++++++++
net/sctp/sm_statefuns.c | 24 ++++++++++++++++++++++++
net/sctp/sm_statetable.c | 2 +-
net/sctp/ulpevent.c | 28 ++++++++++++++++++++++++++++
6 files changed, 74 insertions(+), 1 deletions(-)
diff --git a/include/net/sctp/sm.h b/include/net/sctp/sm.h
index 9352d12..49db0c7 100644
--- a/include/net/sctp/sm.h
+++ b/include/net/sctp/sm.h
@@ -165,6 +165,7 @@ sctp_state_fn_t sctp_sf_do_prm_requestheartbeat;
sctp_state_fn_t sctp_sf_do_prm_asconf;
/* Prototypes for other event state functions. */
+sctp_state_fn_t sctp_sf_do_no_pending_tsn;
sctp_state_fn_t sctp_sf_do_9_2_start_shutdown;
sctp_state_fn_t sctp_sf_do_9_2_shutdown_ack;
sctp_state_fn_t sctp_sf_ignore_other;
diff --git a/include/net/sctp/ulpevent.h b/include/net/sctp/ulpevent.h
index 7ea12e8..99b027b 100644
--- a/include/net/sctp/ulpevent.h
+++ b/include/net/sctp/ulpevent.h
@@ -132,6 +132,9 @@ struct sctp_ulpevent *sctp_ulpevent_make_authkey(
const struct sctp_association *asoc, __u16 key_id,
__u32 indication, gfp_t gfp);
+struct sctp_ulpevent *sctp_ulpevent_make_sender_dry_event(
+ const struct sctp_association *asoc, gfp_t gfp);
+
void sctp_ulpevent_read_sndrcvinfo(const struct sctp_ulpevent *event,
struct msghdr *);
__u16 sctp_ulpevent_get_notification_type(const struct sctp_ulpevent *event);
diff --git a/include/net/sctp/user.h b/include/net/sctp/user.h
index 4525d8c..32fd512 100644
--- a/include/net/sctp/user.h
+++ b/include/net/sctp/user.h
@@ -354,6 +354,20 @@ struct sctp_authkey_event {
enum { SCTP_AUTH_NEWKEY = 0, };
+/*
+ * 6.1.9. SCTP_SENDER_DRY_EVENT
+ *
+ * When the SCTP stack has no more user data to send or retransmit, this
+ * notification is given to the user. Also, at the time when a user app
+ * subscribes to this event, if there is no data to be sent or
+ * retransmit, the stack will immediately send up this notification.
+ */
+struct sctp_sender_dry_event {
+ __u16 sender_dry_type;
+ __u16 sender_dry_flags;
+ __u32 sender_dry_length;
+ sctp_assoc_t sender_dry_assoc_id;
+};
/*
* Described in Section 7.3
@@ -369,6 +383,7 @@ struct sctp_event_subscribe {
__u8 sctp_partial_delivery_event;
__u8 sctp_adaptation_layer_event;
__u8 sctp_authentication_event;
+ __u8 sctp_sender_dry_event;
};
/*
@@ -392,6 +407,7 @@ union sctp_notification {
struct sctp_adaptation_event sn_adaptation_event;
struct sctp_pdapi_event sn_pdapi_event;
struct sctp_authkey_event sn_authkey_event;
+ struct sctp_sender_dry_event sn_sender_dry_event;
};
/* Section 5.3.1
@@ -410,6 +426,7 @@ enum sctp_sn_type {
SCTP_ADAPTATION_INDICATION,
SCTP_AUTHENTICATION_EVENT,
#define SCTP_AUTHENTICATION_INDICATION SCTP_AUTHENTICATION_EVENT
+ SCTP_SENDER_DRY_EVENT,
};
/* Notification error codes used to fill up the error fields in some
diff --git a/net/sctp/sm_statefuns.c b/net/sctp/sm_statefuns.c
index 7679208..95257b2 100644
--- a/net/sctp/sm_statefuns.c
+++ b/net/sctp/sm_statefuns.c
@@ -5056,6 +5056,30 @@ sctp_disposition_t sctp_sf_ignore_primitive(
***************************************************************************/
/*
+ * When the SCTP stack has no more user data to send or retransmit, this
+ * notification is given to the user. Also, at the time when a user app
+ * subscribes to this event, if there is no data to be sent or
+ * retransmit, the stack will immediately send up this notification.
+ */
+sctp_disposition_t sctp_sf_do_no_pending_tsn(
+ const struct sctp_endpoint *ep,
+ const struct sctp_association *asoc,
+ const sctp_subtype_t type,
+ void *arg,
+ sctp_cmd_seq_t *commands)
+{
+ struct sctp_ulpevent *event;
+
+ event = sctp_ulpevent_make_sender_dry_event(asoc, GFP_ATOMIC);
+ if (!event)
+ return SCTP_DISPOSITION_NOMEM;
+
+ sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP, SCTP_ULPEVENT(event));
+
+ return SCTP_DISPOSITION_CONSUME;
+}
+
+/*
* Start the shutdown negotiation.
*
* From Section 9.2:
diff --git a/net/sctp/sm_statetable.c b/net/sctp/sm_statetable.c
index 546d438..382fa40 100644
--- a/net/sctp/sm_statetable.c
+++ b/net/sctp/sm_statetable.c
@@ -722,7 +722,7 @@ static const sctp_sm_table_entry_t primitive_event_table[SCTP_NUM_PRIMITIVE_TYPE
/* SCTP_STATE_COOKIE_ECHOED */ \
TYPE_SCTP_FUNC(sctp_sf_ignore_other), \
/* SCTP_STATE_ESTABLISHED */ \
- TYPE_SCTP_FUNC(sctp_sf_ignore_other), \
+ TYPE_SCTP_FUNC(sctp_sf_do_no_pending_tsn), \
/* SCTP_STATE_SHUTDOWN_PENDING */ \
TYPE_SCTP_FUNC(sctp_sf_do_9_2_start_shutdown), \
/* SCTP_STATE_SHUTDOWN_SENT */ \
diff --git a/net/sctp/ulpevent.c b/net/sctp/ulpevent.c
index 62d4a7b..c962c60 100644
--- a/net/sctp/ulpevent.c
+++ b/net/sctp/ulpevent.c
@@ -862,6 +862,34 @@ fail:
return NULL;
}
+/*
+ * Socket Extensions for SCTP
+ * 6.3.10. SCTP_SENDER_DRY_EVENT
+ */
+struct sctp_ulpevent *sctp_ulpevent_make_sender_dry_event(
+ const struct sctp_association *asoc, gfp_t gfp)
+{
+ struct sctp_ulpevent *event;
+ struct sctp_sender_dry_event *sdry;
+ struct sk_buff *skb;
+
+ event = sctp_ulpevent_new(sizeof(struct sctp_sender_dry_event),
+ MSG_NOTIFICATION, gfp);
+ if (!event)
+ return NULL;
+
+ skb = sctp_event2skb(event);
+ sdry = (struct sctp_sender_dry_event *)
+ skb_put(skb, sizeof(struct sctp_sender_dry_event));
+
+ sdry->sender_dry_type = SCTP_SENDER_DRY_EVENT;
+ sdry->sender_dry_flags = 0;
+ sdry->sender_dry_length = sizeof(struct sctp_sender_dry_event);
+ sctp_ulpevent_set_owner(event, asoc);
+ sdry->sender_dry_assoc_id = sctp_assoc2id(asoc);
+
+ return event;
+}
/* Return the notification type, assuming this is a notification
* event.
--
1.6.5.2
^ permalink raw reply related
* [PATCH net-next-2.6 2/3] sctp: change auth event type name to SCTP_AUTHENTICATION_EVENT
From: Wei Yongjun @ 2011-04-18 3:28 UTC (permalink / raw)
To: David Miller; +Cc: netdev@vger.kernel.org, lksctp
In-Reply-To: <4DABAEF1.1010506@cn.fujitsu.com>
This patch change the auth event type name to SCTP_AUTHENTICATION_EVENT,
which is based on API extension compliance.
Signed-off-by: Wei Yongjun <yjwei@cn.fujitsu.com>
Signed-off-by: Vlad Yasevich <vladislav.yasevich@hp.com>
---
include/net/sctp/user.h | 3 ++-
net/sctp/ulpevent.c | 2 +-
2 files changed, 3 insertions(+), 2 deletions(-)
diff --git a/include/net/sctp/user.h b/include/net/sctp/user.h
index 793617e..4525d8c 100644
--- a/include/net/sctp/user.h
+++ b/include/net/sctp/user.h
@@ -408,7 +408,8 @@ enum sctp_sn_type {
SCTP_SHUTDOWN_EVENT,
SCTP_PARTIAL_DELIVERY_EVENT,
SCTP_ADAPTATION_INDICATION,
- SCTP_AUTHENTICATION_INDICATION,
+ SCTP_AUTHENTICATION_EVENT,
+#define SCTP_AUTHENTICATION_INDICATION SCTP_AUTHENTICATION_EVENT
};
/* Notification error codes used to fill up the error fields in some
diff --git a/net/sctp/ulpevent.c b/net/sctp/ulpevent.c
index dff27d5..62d4a7b 100644
--- a/net/sctp/ulpevent.c
+++ b/net/sctp/ulpevent.c
@@ -843,7 +843,7 @@ struct sctp_ulpevent *sctp_ulpevent_make_authkey(
ak = (struct sctp_authkey_event *)
skb_put(skb, sizeof(struct sctp_authkey_event));
- ak->auth_type = SCTP_AUTHENTICATION_INDICATION;
+ ak->auth_type = SCTP_AUTHENTICATION_EVENT;
ak->auth_flags = 0;
ak->auth_length = sizeof(struct sctp_authkey_event);
--
1.6.5.2
^ permalink raw reply related
* [PATCH net-next-2.6 1/3] sctp: implement socket option SCTP_GET_ASSOC_ID_LIST
From: Wei Yongjun @ 2011-04-18 3:27 UTC (permalink / raw)
To: David Miller; +Cc: netdev@vger.kernel.org, lksctp
In-Reply-To: <4DABAEF1.1010506@cn.fujitsu.com>
This patch Implement socket option SCTP_GET_ASSOC_ID_LIST.
SCTP Socket API Extension:
8.2.6. Get the Current Identifiers of Associations
(SCTP_GET_ASSOC_ID_LIST)
This option gets the current list of SCTP association identifiers of
the SCTP associations handled by a one-to-many style socket.
Signed-off-by: Wei Yongjun <yjwei@cn.fujitsu.com>
Signed-off-by: Vlad Yasevich <vladislav.yasevich@hp.com>
---
include/net/sctp/user.h | 13 +++++++++++
net/sctp/socket.c | 52 +++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 65 insertions(+), 0 deletions(-)
diff --git a/include/net/sctp/user.h b/include/net/sctp/user.h
index e73ebda..793617e 100644
--- a/include/net/sctp/user.h
+++ b/include/net/sctp/user.h
@@ -91,6 +91,7 @@ typedef __s32 sctp_assoc_t;
#define SCTP_PEER_AUTH_CHUNKS 26 /* Read only */
#define SCTP_LOCAL_AUTH_CHUNKS 27 /* Read only */
#define SCTP_GET_ASSOC_NUMBER 28 /* Read only */
+#define SCTP_GET_ASSOC_ID_LIST 29 /* Read only */
/* Internal Socket Options. Some of the sctp library functions are
* implemented using these socket options.
@@ -669,6 +670,18 @@ struct sctp_authchunks {
};
/*
+ * 8.2.6. Get the Current Identifiers of Associations
+ * (SCTP_GET_ASSOC_ID_LIST)
+ *
+ * This option gets the current list of SCTP association identifiers of
+ * the SCTP associations handled by a one-to-many style socket.
+ */
+struct sctp_assoc_ids {
+ __u32 gaids_number_of_ids;
+ sctp_assoc_t gaids_assoc_id[];
+};
+
+/*
* 8.3, 8.5 get all peer/local addresses in an association.
* This parameter struct is used by SCTP_GET_PEER_ADDRS and
* SCTP_GET_LOCAL_ADDRS socket options used internally to implement
diff --git a/net/sctp/socket.c b/net/sctp/socket.c
index deb82e3..7bdeae7 100644
--- a/net/sctp/socket.c
+++ b/net/sctp/socket.c
@@ -5283,6 +5283,55 @@ static int sctp_getsockopt_assoc_number(struct sock *sk, int len,
return 0;
}
+/*
+ * 8.2.6. Get the Current Identifiers of Associations
+ * (SCTP_GET_ASSOC_ID_LIST)
+ *
+ * This option gets the current list of SCTP association identifiers of
+ * the SCTP associations handled by a one-to-many style socket.
+ */
+static int sctp_getsockopt_assoc_ids(struct sock *sk, int len,
+ char __user *optval, int __user *optlen)
+{
+ struct sctp_sock *sp = sctp_sk(sk);
+ struct sctp_association *asoc;
+ struct sctp_assoc_ids *ids;
+ u32 num = 0;
+
+ if (sctp_style(sk, TCP))
+ return -EOPNOTSUPP;
+
+ if (len < sizeof(struct sctp_assoc_ids))
+ return -EINVAL;
+
+ list_for_each_entry(asoc, &(sp->ep->asocs), asocs) {
+ num++;
+ }
+
+ if (len < sizeof(struct sctp_assoc_ids) + sizeof(sctp_assoc_t) * num)
+ return -EINVAL;
+
+ len = sizeof(struct sctp_assoc_ids) + sizeof(sctp_assoc_t) * num;
+
+ ids = kmalloc(len, GFP_KERNEL);
+ if (unlikely(!ids))
+ return -ENOMEM;
+
+ ids->gaids_number_of_ids = num;
+ num = 0;
+ list_for_each_entry(asoc, &(sp->ep->asocs), asocs) {
+ ids->gaids_assoc_id[num++] = asoc->assoc_id;
+ }
+
+ if (put_user(len, optlen) || copy_to_user(optval, ids, len)) {
+ kfree(ids);
+ return -EFAULT;
+ }
+
+ kfree(ids);
+ return 0;
+}
+
SCTP_STATIC int sctp_getsockopt(struct sock *sk, int level, int optname,
char __user *optval, int __user *optlen)
{
@@ -5415,6 +5464,9 @@ SCTP_STATIC int sctp_getsockopt(struct sock *sk, int level, int optname,
case SCTP_GET_ASSOC_NUMBER:
retval = sctp_getsockopt_assoc_number(sk, len, optval, optlen);
break;
+ case SCTP_GET_ASSOC_ID_LIST:
+ retval = sctp_getsockopt_assoc_ids(sk, len, optval, optlen);
+ break;
default:
retval = -ENOPROTOOPT;
break;
--
1.6.5.2
^ permalink raw reply related
* [PATCH net-next-2.6 0/3] new SCTP sockets APIs
From: Wei Yongjun @ 2011-04-18 3:24 UTC (permalink / raw)
To: David Miller; +Cc: netdev@vger.kernel.org, lksctp
This patchset implement some new sockets APIs for net-next-2.6.
Wei Yongjun (3):
sctp: implement socket option SCTP_GET_ASSOC_ID_LIST
sctp: change auth event type name to SCTP_AUTHENTICATION_EVENT
sctp: implement event notification SCTP_SENDER_DRY_EVENT
include/net/sctp/sm.h | 1 +
include/net/sctp/ulpevent.h | 3 ++
include/net/sctp/user.h | 33 ++++++++++++++++++++++++++-
net/sctp/sm_statefuns.c | 24 +++++++++++++++++++
net/sctp/sm_statetable.c | 2 +-
net/sctp/socket.c | 52 +++++++++++++++++++++++++++++++++++++++++++
net/sctp/ulpevent.c | 30 ++++++++++++++++++++++++-
7 files changed, 142 insertions(+), 3 deletions(-)
^ permalink raw reply
* [PATCH v2 27/27] HFI: hfi_ip ethtool support
From: dykmanj @ 2011-04-18 3:21 UTC (permalink / raw)
To: netdev
Cc: Jim Dykman, Piyush Chaudhary, Fu-Chung Chang, William S. Cadden,
Wen C. Chen, Scot Sakolish, Jian Xiao, Carol L. Soto,
Sarah J. Sheppard
In-Reply-To: <1303096919-7367-1-git-send-email-dykmanj@linux.vnet.ibm.com>
From: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Piyush Chaudhary <piyushc@linux.vnet.ibm.com>
Signed-off-by: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
Signed-off-by: William S. Cadden <wscadden@linux.vnet.ibm.com>
Signed-off-by: Wen C. Chen <winstonc@linux.vnet.ibm.com>
Signed-off-by: Scot Sakolish <sakolish@linux.vnet.ibm.com>
Signed-off-by: Jian Xiao <jian@linux.vnet.ibm.com>
Signed-off-by: Carol L. Soto <clsoto@linux.vnet.ibm.com>
Signed-off-by: Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
---
drivers/net/hfi/ip/Makefile | 2 +-
drivers/net/hfi/ip/hf_ethtool.c | 136 ++++++++++++++++++++++++++++++++++++++
drivers/net/hfi/ip/hf_proto.h | 1 +
drivers/net/hfi/ip/hfi_ip_main.c | 36 +++++++++-
include/linux/hfi/hfi_ip.h | 32 +++++++++-
5 files changed, 201 insertions(+), 6 deletions(-)
create mode 100644 drivers/net/hfi/ip/hf_ethtool.c
diff --git a/drivers/net/hfi/ip/Makefile b/drivers/net/hfi/ip/Makefile
index 90c7dea..28a4a51 100644
--- a/drivers/net/hfi/ip/Makefile
+++ b/drivers/net/hfi/ip/Makefile
@@ -3,4 +3,4 @@
#
obj-$(CONFIG_HFI_IP) += hfi_ip.o
-hfi_ip-objs := hfi_ip_main.o
+hfi_ip-objs := hfi_ip_main.o hf_ethtool.o
diff --git a/drivers/net/hfi/ip/hf_ethtool.c b/drivers/net/hfi/ip/hf_ethtool.c
new file mode 100644
index 0000000..204a1bf
--- /dev/null
+++ b/drivers/net/hfi/ip/hf_ethtool.c
@@ -0,0 +1,136 @@
+/*
+ * hf_ethtool.c
+ *
+ * HF IP driver for IBM System p
+ *
+ * Authors:
+ * Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
+ * William S. Cadden <wscadden@linux.vnet.ibm.com>
+ * Wen C. Chen <winstonc@linux.vnet.ibm.com>
+ * Scot Sakolish <sakolish@linux.vnet.ibm.com>
+ * Jian Xiao <jian@linux.vnet.ibm.com>
+ * Carol L. Soto <clsoto@linux.vnet.ibm.com>
+ * Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
+ *
+ * (C) Copyright IBM Corp. 2010
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include <linux/ethtool.h>
+
+#include <linux/hfi/hfi_ip.h>
+
+static char hf_ethtool_stats_keys[][ETH_GSTRING_LEN] = {
+ {"sfifo_packets"},
+ {"rdma_packets"},
+ {"tx_timeout"},
+ {"tx_queue_stop"},
+ {"tx_drop"},
+ {"tx_err_headlen"},
+ {"rx_version_mismatch"},
+ {"rx_err_restore"},
+ {"rx_err_cookie"},
+ {"rx_err_skb"},
+ {"rx_err_hdr_type"},
+ {"rx_err_msg_type"},
+ {"rx_err_status"},
+ {"rx_err_bcast_csum"},
+ {"rx_fslot_debt"},
+ {"mmio_rx_inc_avail"},
+ {"mmio_rx_post_desc"},
+ {"payload_sent"},
+ {"desc_sent"},
+ {"large_bcast_sent"},
+ {"super_sent"},
+ {"payload_recv"},
+ {"desc_recv"},
+ {"rdma_write"},
+ {"rdma_write_fail"},
+ {"rdma_cancel"},
+ {"rdma_cancel_fail"},
+ {"rdma_cancel_already"},
+ {"rdma_rndz_request_sent"},
+ {"rdma_rndz_request_fail"},
+ {"rdma_rndz_reply_recv"},
+ {"rdma_rndz_reply_fail"},
+ {"rdma_rndz_request_recv"},
+ {"rdma_rndz_reply_sent"},
+ {"bad_rdma_notification"},
+ {"bad_rdma_first_notification"},
+ {"rdma_src_completion"},
+ {"rdma_sink_completion"},
+ {"rdma_send_timeout"},
+ {"rdma_recv_timeout"},
+ {"sfifo_send_intr_armed"},
+ {"rdma_send_intr_armed"},
+ {"recv_intr_armed"},
+ {"recv_intr_offset"},
+ {"recv_imm_intr_armed"},
+ {"recv_imm_intr_offset"},
+ {"send_intr_fired"},
+ {"recv_intr_fired"},
+ {"in_poll"},
+ {"max_poll_recv"},
+};
+
+static void hf_get_drvinfo(struct net_device *netdev,
+ struct ethtool_drvinfo *info)
+{
+ strlcpy(info->driver, HF_DRV_NAME, sizeof(info->driver));
+ strlcpy(info->version, HF_DRV_VERSION, sizeof(info->version));
+}
+
+static void hf_get_strings(struct net_device *netdev, u32 stringset, u8 *data)
+{
+ switch (stringset) {
+ case ETH_SS_STATS:
+ memcpy(data, &hf_ethtool_stats_keys,
+ sizeof(hf_ethtool_stats_keys));
+ break;
+ }
+}
+
+static int hf_get_sset_count(struct net_device *netdev, int sset)
+{
+ switch (sset) {
+ case ETH_SS_STATS:
+ return ARRAY_SIZE(hf_ethtool_stats_keys);
+ default:
+ return -EINVAL;
+ }
+}
+
+static void hf_get_ethtool_stats(struct net_device *netdev,
+ struct ethtool_stats *stats, u64 *data)
+{
+ struct hf_net *net = netdev_priv(netdev);
+ struct hf_if *net_if = &(net->hfif);
+
+ memcpy(data, &(net_if->eth_stats), sizeof(struct hf_ethtool_stats));
+}
+
+static const struct ethtool_ops hf_ethtool_ops = {
+ .get_drvinfo = hf_get_drvinfo,
+ .get_strings = hf_get_strings,
+ .get_sset_count = hf_get_sset_count,
+ .get_ethtool_stats = hf_get_ethtool_stats,
+};
+
+void hf_set_ethtool_ops(struct net_device *netdev)
+{
+ SET_ETHTOOL_OPS(netdev, &hf_ethtool_ops);
+}
diff --git a/drivers/net/hfi/ip/hf_proto.h b/drivers/net/hfi/ip/hf_proto.h
index 022512a..3b2b23b 100644
--- a/drivers/net/hfi/ip/hf_proto.h
+++ b/drivers/net/hfi/ip/hf_proto.h
@@ -36,6 +36,7 @@
int hf_tx_check_avail(struct hf_net *net, u32 xmit_cls);
void hf_construct_hwhdr(struct hf_if *net_if, struct sk_buff *skb,
struct base_hdr *b_hdr);
+void hf_set_ethtool_ops(struct net_device *netdev);
extern int hfidd_open_window_func(struct hfidd_acs *p_acs,
u32 is_userspace,
struct hfi_client_info *user_p,
diff --git a/drivers/net/hfi/ip/hfi_ip_main.c b/drivers/net/hfi/ip/hfi_ip_main.c
index 6b2ec3f..4b897d3 100644
--- a/drivers/net/hfi/ip/hfi_ip_main.c
+++ b/drivers/net/hfi/ip/hfi_ip_main.c
@@ -208,6 +208,7 @@ static int hf_send_intr_callback(void *parm, u32 win, u32 ext)
mb();
netif_wake_queue(net->netdev);
+ net->hfif.eth_stats.send_intr_fired++;
return 0;
}
@@ -218,6 +219,7 @@ static int hf_recv_intr_callback(void *parm, u32 win, u32 ext)
napi_schedule(&(net->napi));
+ net->hfif.eth_stats.recv_intr_fired++;
return 0;
}
@@ -381,6 +383,9 @@ static void hf_set_recv_intr(struct hf_if *net_if)
hf_mmio_regs_write_then_read(net_if, HFI_RFIFO_INTR_REG,
(HF_ENA_RECV_INTR + (offset << HF_RECV_INTR_MATCH_SHIFT)));
+ net_if->eth_stats.recv_intr_offset = offset;
+ net_if->eth_stats.recv_intr_armed++;
+
/* check if there is packet received in the mean time */
rx_pkt = net_if->rx_fifo.addr + (offset << HFI_CACHE_LINE_SHIFT);
@@ -390,6 +395,9 @@ static void hf_set_recv_intr(struct hf_if *net_if)
/* force an immediate recv intr */
hf_mmio_regs_write(net_if, HFI_RFIFO_INTR_REG,
(HF_IMM_RECV_INTR + (offset << HF_RECV_INTR_MATCH_SHIFT)));
+
+ net_if->eth_stats.recv_imm_intr_offset = offset;
+ net_if->eth_stats.recv_imm_intr_armed++;
}
}
@@ -507,7 +515,7 @@ static int hf_net_open(struct net_device *netdev)
struct hfidd_acs *p_acs = HF_ACS(net_if);
memset(&(netdev->stats), 0, sizeof(struct net_device_stats));
- net_if->sfifo_packets = 0;
+ memset(&(net_if->eth_stats), 0, sizeof(struct hf_ethtool_stats));
spin_lock(&(net_if->lock));
net_if->state = HF_NET_HALF_OPEN;
@@ -614,6 +622,7 @@ static inline int hf_check_hdr_version(struct hf_net *net,
"hf_check_hdr_version: hdr version 0x%x "
"does not match 0x%x\n",
hf_hdr->version, HF_PROTO_HDR_VERSION);
+ net->hfif.eth_stats.rx_version_mismatch++;
net->netdev->stats.rx_dropped++;
return -EINVAL;
}
@@ -710,6 +719,7 @@ static void hf_recv_ip_with_payload(struct hf_net *net,
netdev->stats.rx_packets++;
netdev->stats.rx_bytes += skb->len;
+ net_if->eth_stats.payload_recv++;
netif_receive_skb(skb);
}
@@ -717,6 +727,8 @@ static void hf_recv_ip_good(struct hf_net *net,
struct hfi_hdr *rx_curr,
u32 pkt_len)
{
+ struct hf_if *net_if = &(net->hfif);
+
switch (rx_curr->type.header_type) {
case HFI_IP_WITH_PAYLOAD:
@@ -731,6 +743,7 @@ static void hf_recv_ip_good(struct hf_net *net,
rx_curr->type.header_type, pkt_len);
/* unknown packet, drop it */
+ net_if->eth_stats.rx_err_hdr_type++;
net->netdev->stats.rx_dropped++;
break;
}
@@ -767,6 +780,7 @@ static int hf_rx(struct hf_net *net, int budget)
"status = 0x%x, pkt_len = 0x%x\n",
status, pkt_len);
+ net_if->eth_stats.rx_err_status++;
net->netdev->stats.rx_dropped++;
}
@@ -782,6 +796,7 @@ static int hf_rx(struct hf_net *net, int budget)
hf_mmio_regs_write(net_if, HFI_RFIFO_INC_FSLOT_REG,
net_if->rx_fslot_debt);
net_if->rx_fslot_debt = 0;
+ net_if->eth_stats.mmio_rx_inc_avail++;
}
budget--;
@@ -791,6 +806,7 @@ static int hf_rx(struct hf_net *net, int budget)
}
+ net_if->eth_stats.rx_fslot_debt = net_if->rx_fslot_debt;
netdev_dbg(net->netdev, "hf_rx: exit, head = 0x%x, recv 0x%x pkts\n",
net_if->rx_fifo.head, num);
@@ -860,9 +876,10 @@ int hf_tx_check_avail(struct hf_net *net, u32 xmit_cls)
u64 intr_thresh;
netif_stop_queue(netdev);
+ net_if->eth_stats.tx_queue_stop++;
/* turn on transmit interrupt */
- intr_thresh = (net_if->sfifo_packets -
+ intr_thresh = (net_if->eth_stats.sfifo_packets -
HF_SFIFO_INTR_WATERMARK) & HF_SFIFO_INTR_MASK;
intr_cntl = HF_SFIFO_INTR_ENABLE |
@@ -871,6 +888,7 @@ int hf_tx_check_avail(struct hf_net *net, u32 xmit_cls)
hf_mmio_regs_write_then_read(net_if,
HFI_SFIFO_INTR_CNTL, intr_cntl);
+ net_if->eth_stats.sfifo_send_intr_armed++;
return -EBUSY;
}
}
@@ -957,6 +975,7 @@ static char *hf_build_payload_hdr(struct hf_net *net,
" not supported\n", hwhdr_p->h_proto);
dev_kfree_skb_any(skb);
+ net_if->eth_stats.tx_drop++;
return NULL;
}
@@ -1051,7 +1070,8 @@ static int hf_payload_tx(struct sk_buff *skb, struct hf_net *net, u32 is_bcast)
(net_if->tx_fifo.tail + xmit_cls) & (net_if->tx_fifo.emax);
atomic_sub(xmit_cls, &(net_if->tx_fifo.avail));
- net_if->sfifo_packets++;
+ net_if->eth_stats.sfifo_packets++;
+ net_if->eth_stats.payload_sent++;
net->netdev->stats.tx_packets++;
net->netdev->stats.tx_bytes += msg_len;
@@ -1079,6 +1099,7 @@ static int hf_start_xmit(struct sk_buff *skb, struct net_device *netdev)
netdev_err(netdev, "hf_start_xmit: invalid skb->len 0x%x\n",
skb->len);
dev_kfree_skb_any(skb);
+ net_if->eth_stats.tx_drop++;
return NETDEV_TX_OK;
}
@@ -1119,8 +1140,12 @@ static int hf_start_xmit(struct sk_buff *skb, struct net_device *netdev)
static void hf_tx_timeout(struct net_device *netdev)
{
+ struct hf_net *net = netdev_priv(netdev);
+ struct hf_if *net_if = &(net->hfif);
+
netdev_warn(netdev, "hf_tx_timeout: queue_stopped is %d\n",
netif_queue_stopped(netdev));
+ net_if->eth_stats.tx_timeout++;
}
static int hf_change_mtu(struct net_device *netdev, int new_mtu)
@@ -1207,6 +1232,7 @@ static int hf_poll(struct napi_struct *napi, int budget)
net_if = &(net->hfif);
netdev = net->netdev;
+ net_if->eth_stats.in_poll++;
work_done = hf_rx(net, budget);
/* Always assume we have received all available packets */
@@ -1215,7 +1241,8 @@ static int hf_poll(struct napi_struct *napi, int budget)
napi_complete(napi);
isync();
hf_set_recv_intr(net_if);
- }
+ } else
+ net_if->eth_stats.max_poll_recv++;
return work_done;
}
@@ -1248,6 +1275,7 @@ static struct hf_net *hf_init_netdev(int idx, int ai)
net->hfif.state = HF_NET_CLOSE;
spin_lock_init(&net->hfif.lock);
+ hf_set_ethtool_ops(netdev);
rc = register_netdev(netdev);
if (rc) {
diff --git a/include/linux/hfi/hfi_ip.h b/include/linux/hfi/hfi_ip.h
index ec87300..d4317ee 100644
--- a/include/linux/hfi/hfi_ip.h
+++ b/include/linux/hfi/hfi_ip.h
@@ -42,6 +42,7 @@
#include <net/arp.h>
#include <linux/hfi/hfidd_internal.h>
+#include <linux/hfi/hfidd_adpt.h>
#include <linux/hfi/hfidd_client.h>
#include <linux/hfi/hfidd_requests.h>
#include <linux/hfi/hfidd_regs.h>
@@ -150,6 +151,35 @@ struct hf_fifo {
#define HF_NET_HALF_OPEN 0xA0
#define HF_NET_OPEN 0xA1
+struct hf_ethtool_stats {
+ u64 sfifo_packets; /* total packets send through sfifo */
+ u64 tx_timeout;
+ u64 tx_queue_stop;
+ u64 tx_drop;
+ u64 tx_err_headlen;
+ u64 rx_version_mismatch;
+ u64 rx_err_skb;
+ u64 rx_err_hdr_type;
+ u64 rx_err_msg_type;
+ u64 rx_err_status;
+ u64 rx_err_bcast_csum;
+ u64 rx_fslot_debt;
+ u64 mmio_rx_inc_avail;
+ u64 payload_sent; /* packets from IP send with payload
+ mode */
+ u64 payload_recv; /* packets delivered to IP with payload
+ mode */
+ u64 sfifo_send_intr_armed;
+ u64 recv_intr_armed;
+ u64 recv_intr_offset;
+ u64 recv_imm_intr_armed;
+ u64 recv_imm_intr_offset;
+ u64 send_intr_fired;
+ u64 recv_intr_fired;
+ u64 in_poll;
+ u64 max_poll_recv;
+};
+
struct hf_if {
u32 idx; /* 0, 1, 2, 3 ... */
u32 ai; /* 0=hfi0, 1=hfi1 */
@@ -160,7 +190,6 @@ struct hf_if {
spinlock_t lock; /* lock for state */
u32 sfifo_fv_polarity;
u32 sfifo_slots_per_blk;
- u32 sfifo_packets;
u32 rx_pkt_valid; /* Polarity of recv
packet valid bit */
u32 msg_id;
@@ -172,6 +201,7 @@ struct hf_if {
struct sk_buff **tx_skb; /* array to store tx
2k skb */
void *sfifo_finishvec;
+ struct hf_ethtool_stats eth_stats;
};
/* Private structure for HF inetrface */
--
1.7.3.5
^ permalink raw reply related
* [PATCH v2 24/27] HFI: hfi_ip network driver
From: dykmanj @ 2011-04-18 3:21 UTC (permalink / raw)
To: netdev
Cc: Jim Dykman, Piyush Chaudhary, Fu-Chung Chang, William S. Cadden,
Wen C. Chen, Scot Sakolish, Jian Xiao, Carol L. Soto,
Sarah J. Sheppard
In-Reply-To: <1303096919-7367-1-git-send-email-dykmanj@linux.vnet.ibm.com>
From: Jim Dykman <dykmanj@linux.vnet.ibm.com>
It is a separate binary because it is not strictly necessary to use the HFI.
This patch includes module load/unload and the window open/setup with the
hfi device driver.
Signed-off-by: Piyush Chaudhary <piyushc@linux.vnet.ibm.com>
Signed-off-by: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
Signed-off-by: William S. Cadden <wscadden@linux.vnet.ibm.com>
Signed-off-by: Wen C. Chen <winstonc@linux.vnet.ibm.com>
Signed-off-by: Scot Sakolish <sakolish@linux.vnet.ibm.com>
Signed-off-by: Jian Xiao <jian@linux.vnet.ibm.com>
Signed-off-by: Carol L. Soto <clsoto@linux.vnet.ibm.com>
Signed-off-by: Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
---
drivers/net/Kconfig | 1 +
drivers/net/hfi/Makefile | 1 +
drivers/net/hfi/ip/Kconfig | 9 +
drivers/net/hfi/ip/Makefile | 6 +
drivers/net/hfi/ip/hf_proto.h | 48 +++
drivers/net/hfi/ip/hfi_ip_main.c | 613 ++++++++++++++++++++++++++++++++++++++
include/linux/hfi/hfi_ip.h | 148 +++++++++
include/linux/if_arp.h | 1 +
8 files changed, 827 insertions(+), 0 deletions(-)
create mode 100644 drivers/net/hfi/ip/Kconfig
create mode 100644 drivers/net/hfi/ip/Makefile
create mode 100644 drivers/net/hfi/ip/hf_proto.h
create mode 100644 drivers/net/hfi/ip/hfi_ip_main.c
create mode 100644 include/linux/hfi/hfi_ip.h
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 1abbfd9..ddae700 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -3437,5 +3437,6 @@ config VMXNET3
module will be called vmxnet3.
source "drivers/net/hfi/core/Kconfig"
+source "drivers/net/hfi/ip/Kconfig"
endif # NETDEVICES
diff --git a/drivers/net/hfi/Makefile b/drivers/net/hfi/Makefile
index 0440cbe..768f27c 100644
--- a/drivers/net/hfi/Makefile
+++ b/drivers/net/hfi/Makefile
@@ -1 +1,2 @@
obj-$(CONFIG_HFI) += core/
+obj-$(CONFIG_HFI_IP) += ip/
diff --git a/drivers/net/hfi/ip/Kconfig b/drivers/net/hfi/ip/Kconfig
new file mode 100644
index 0000000..422782a
--- /dev/null
+++ b/drivers/net/hfi/ip/Kconfig
@@ -0,0 +1,9 @@
+config HFI_IP
+ tristate "IP-over-HFI"
+ depends on NETDEVICES && INET && HFI
+ ---help---
+ Support for IP over HFI. It transports IP
+ packets over HFI.
+
+ To compile the driver as a module, choose M here. The module
+ will be called hfi_ip.
diff --git a/drivers/net/hfi/ip/Makefile b/drivers/net/hfi/ip/Makefile
new file mode 100644
index 0000000..90c7dea
--- /dev/null
+++ b/drivers/net/hfi/ip/Makefile
@@ -0,0 +1,6 @@
+#
+# Makefile for the HF IP interface for IBM eServer System p
+#
+obj-$(CONFIG_HFI_IP) += hfi_ip.o
+
+hfi_ip-objs := hfi_ip_main.o
diff --git a/drivers/net/hfi/ip/hf_proto.h b/drivers/net/hfi/ip/hf_proto.h
new file mode 100644
index 0000000..b4133b7
--- /dev/null
+++ b/drivers/net/hfi/ip/hf_proto.h
@@ -0,0 +1,48 @@
+/*
+ * hf_proto.h
+ *
+ * HF IP driver for IBM System p
+ *
+ * Authors:
+ * Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
+ * William S. Cadden <wscadden@linux.vnet.ibm.com>
+ * Wen C. Chen <winstonc@linux.vnet.ibm.com>
+ * Scot Sakolish <sakolish@linux.vnet.ibm.com>
+ * Jian Xiao <jian@linux.vnet.ibm.com>
+ * Carol L. Soto <clsoto@linux.vnet.ibm.com>
+ * Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
+ *
+ * (C) Copyright IBM Corp. 2010
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#ifndef _HF_PROTO_H_
+#define _HF_PROTO_H_
+
+extern int hfidd_open_window_func(struct hfidd_acs *p_acs,
+ u32 is_userspace,
+ struct hfi_client_info *user_p,
+ struct hfi_client_info *out_p);
+extern int hfidd_close_window_func(struct hfidd_acs *p_acs,
+ u32 is_userspace,
+ struct hfi_window_info *user_p);
+extern int hfidd_callback_register(struct hfidd_acs *p_acs,
+ struct hfi_reg_events *arg);
+extern int hfidd_callback_unregister(struct hfidd_acs *p_acs,
+ struct hfi_reg_events *arg);
+
+#endif
diff --git a/drivers/net/hfi/ip/hfi_ip_main.c b/drivers/net/hfi/ip/hfi_ip_main.c
new file mode 100644
index 0000000..0c1ebd7
--- /dev/null
+++ b/drivers/net/hfi/ip/hfi_ip_main.c
@@ -0,0 +1,613 @@
+/*
+ * hfi_ip_main.c
+ *
+ * HF IP driver for IBM System p
+ *
+ * Authors:
+ * Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
+ * William S. Cadden <wscadden@linux.vnet.ibm.com>
+ * Wen C. Chen <winstonc@linux.vnet.ibm.com>
+ * Scot Sakolish <sakolish@linux.vnet.ibm.com>
+ * Jian Xiao <jian@linux.vnet.ibm.com>
+ * Carol L. Soto <clsoto@linux.vnet.ibm.com>
+ * Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
+ *
+ * (C) Copyright IBM Corp. 2010
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include <linux/hfi/hfi_ip.h>
+#include "hf_proto.h"
+
+MODULE_AUTHOR("James Dykman <dykmanj@linux.vnet.ibm.com>, "
+ "Piyush Chaudhary <piyushc@linux.vnet.ibm.com>");
+MODULE_DESCRIPTION("IP driver v" HF_DRV_VERSION " (" HF_DRV_RELDATE ")"
+ " for IBM eServer HFI for System p");
+MODULE_VERSION(HF_DRV_VERSION);
+MODULE_LICENSE("GPL v2");
+
+struct hf_global_info hf_ginfo;
+
+static const u8 hfi_bcast_addr[] = {
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+};
+
+static void hf_free_tx_resource(struct hf_if *net_if)
+{
+ int i;
+
+ if (net_if->tx_skb) {
+ for (i = 0; i <= net_if->tx_fifo.emax; i++) {
+ if (net_if->tx_skb[i])
+ dev_kfree_skb_any(net_if->tx_skb[i]);
+ }
+
+ free_pages((unsigned long)(net_if->tx_skb),
+ get_order((net_if->tx_fifo.emax + 1) *
+ sizeof(struct sk_buff *)));
+ net_if->tx_skb = 0;
+ }
+ if (net_if->tx_fifo.addr) {
+ free_pages((unsigned long)(net_if->tx_fifo.addr),
+ get_order(net_if->tx_fifo.size + PAGE_SIZE_4K));
+ net_if->tx_fifo.addr = 0;
+ }
+}
+
+static int hf_alloc_tx_resource(struct hf_net *net)
+{
+ struct hf_if *net_if = &(net->hfif);
+ int i;
+
+ net_if->tx_fifo.size = HF_SFIFO_SIZE;
+ net_if->tx_fifo.head = 0;
+ net_if->tx_fifo.tail = 0;
+ net_if->tx_fifo.emax = HF_SFIFO_SLOTS - 1;
+ atomic_set(&net_if->tx_fifo.avail, HF_SFIFO_SLOTS - 1);
+
+ net_if->tx_fifo.addr =
+ (void *)__get_free_pages(GFP_KERNEL,
+ get_order(net_if->tx_fifo.size + PAGE_SIZE_4K));
+
+ if (net_if->tx_fifo.addr == 0) {
+ netdev_err(net->netdev, "%s: hf_alloc_tx_resource: "
+ "tx_fifo fail, size=0x%x\n",
+ net_if->name, net_if->tx_fifo.size);
+
+ return -ENOMEM;
+ }
+ memset(net_if->tx_fifo.addr, 0, net_if->tx_fifo.size + PAGE_SIZE_4K);
+
+ /* Sfifo finish vector locates at very next page of sfifo */
+ net_if->sfifo_finishvec = net_if->tx_fifo.addr + net_if->tx_fifo.size;
+ net_if->sfifo_fv_polarity = 0;
+ net_if->sfifo_slots_per_blk = HF_SFIFO_SLOTS / HF_FV_BIT_CNT;
+
+ /* allocate array to hold the tx skbs */
+ net_if->tx_skb =
+ (struct sk_buff **)__get_free_pages(GFP_KERNEL,
+ get_order((net_if->tx_fifo.emax + 1) *
+ sizeof(struct sk_buff *)));
+
+ if (net_if->tx_skb == 0) {
+ netdev_err(net->netdev,
+ "%s: hf_alloc_tx_resource: tx_skb failed\n",
+ net_if->name);
+
+ goto err_out;
+ }
+
+ for (i = 0; i <= net_if->tx_fifo.emax; i++)
+ net_if->tx_skb[i] = NULL;
+
+ return 0;
+
+err_out:
+ hf_free_tx_resource(net_if);
+
+ return -ENOMEM;
+}
+
+static void hf_free_rx_resource(struct hf_if *net_if)
+{
+ if (net_if->rx_fifo.addr) {
+ free_pages((unsigned long)(net_if->rx_fifo.addr),
+ get_order(net_if->rx_fifo.size));
+ net_if->rx_fifo.addr = 0;
+ }
+}
+
+static int hf_alloc_rx_resource(struct hf_net *net)
+{
+ struct hf_if *net_if = &(net->hfif);
+
+ net_if->rx_fifo.size = HF_RFIFO_SIZE;
+ net_if->rx_fifo.head = 0;
+ net_if->rx_fifo.tail = 0;
+ net_if->rx_fifo.emax = HF_RFIFO_SLOTS - 1;
+
+ net_if->rx_fifo.addr =
+ (void *)__get_free_pages(GFP_KERNEL,
+ get_order(net_if->rx_fifo.size));
+
+ if (net_if->rx_fifo.addr == 0) {
+ netdev_err(net->netdev,
+ "%s: hf_alloc_rx_resource: fail, size=0x%x\n",
+ net_if->name, net_if->rx_fifo.size);
+
+ return -ENOMEM;
+ }
+
+ memset(net_if->rx_fifo.addr, 0, net_if->rx_fifo.size);
+
+ return 0;
+}
+
+static void hf_free_resource(struct hf_if *net_if)
+{
+ hf_free_rx_resource(net_if);
+
+ hf_free_tx_resource(net_if);
+}
+
+static int hf_alloc_resource(struct hf_net *net)
+{
+ int rc;
+ struct hf_if *net_if = &(net->hfif);
+
+ rc = hf_alloc_tx_resource(net);
+ if (rc)
+ goto alloc_resource_err0;
+
+ rc = hf_alloc_rx_resource(net);
+ if (rc)
+ goto alloc_resource_err1;
+
+ return 0;
+
+alloc_resource_err1:
+ hf_free_tx_resource(net_if);
+alloc_resource_err0:
+ return rc;
+}
+
+static int hf_close_ip_window(struct hf_net *net, struct hfidd_acs *p_acs)
+{
+ struct hf_if *net_if = &(net->hfif);
+ int rc;
+
+ if (net_if->doorbell) {
+ iounmap(net_if->doorbell);
+ net_if->doorbell = NULL;
+ }
+
+ /* Fill in the request structure */
+ net_if->client.hdr.req = HFIDD_REQ_CLOSE_WINDOW;
+ net_if->client.hdr.req_len = sizeof(struct hfi_window_info);
+ net_if->client.hdr.result.use.kptr = &(net_if->client);
+
+ rc = hfidd_close_window_func(HF_ACS(net_if), 0,
+ (struct hfi_window_info *)(&(net_if->client)));
+ if (rc) {
+ netdev_err(net->netdev,
+ "%s: hf_close_ip_window: fail, rc=0x%x\n",
+ net_if->name, rc);
+ return rc;
+ }
+
+ return 0;
+}
+
+static int hf_open_ip_window(struct hf_net *net,
+ struct hfidd_acs *p_acs)
+{
+ struct hf_if *net_if = &(net->hfif);
+ int rc = 0;
+
+ net_if->client.win_type = HFIDD_IP_WIN;
+
+ net_if->client.sfifo.eaddr.use.kptr = net_if->tx_fifo.addr;
+ net_if->client.sfifo.size = net_if->tx_fifo.size;
+ net_if->client.rfifo.eaddr.use.kptr = net_if->rx_fifo.addr;
+ net_if->client.rfifo.size = net_if->rx_fifo.size;
+ net_if->client.sfifo_finish_vec.use.kptr = net_if->sfifo_finishvec;
+ net_if->client.job_id = HF_IP_JOBID;
+
+ /* Fill in the request structure */
+ net_if->client.hdr.req = HFIDD_REQ_OPEN_WINDOW;
+ net_if->client.hdr.req_len = sizeof(struct hfi_client_info);
+ net_if->client.hdr.result.use.kptr = &(net_if->client);
+
+ rc = hfidd_open_window_func(p_acs, 0, &(net_if->client),
+ &(net_if->client));
+ if (rc) {
+ netdev_err(net->netdev,
+ "%s: hf_open_ip_window: fail open rc=0x%x\n",
+ net_if->name, rc);
+ return rc;
+ }
+
+ net_if->doorbell = (ioremap(
+ (u64)(net_if->client.mmio_regs.use.kptr), PAGE_SIZE_64K));
+
+ if (unlikely(net_if->doorbell == NULL)) {
+ netdev_err(net->netdev,
+ "%s: hf_open_ip_window: fail to map doorbell\n",
+ net_if->name);
+ hf_close_ip_window(net, p_acs);
+ }
+
+ net_if->isr_id = net_if->client.local_isrid;
+
+ return 0;
+}
+
+static int hf_set_mac_addr(struct net_device *netdev, void *p)
+{
+ struct hf_net *net = netdev_priv(netdev);
+ struct hf_if *net_if = &(net->hfif);
+
+ /* Mac address format: 02:ClusterID:ISR:ISR:HFI_WIN:WIN */
+
+ /* Locally administered MAC address */
+ netdev->dev_addr[0] = 0x2; /* bit6=1, bit7=0 */
+
+ netdev->dev_addr[1] = 0x0; /* cluster id */
+
+ *(u16 *)(&(netdev->dev_addr[2])) = (u16)(net_if->isr_id);
+
+ *(u16 *)(&(netdev->dev_addr[4])) = (u16)
+ (((net_if->ai) << HF_MAC_HFI_SHIFT) | (net_if->client.window));
+
+ return 0;
+}
+
+static int hf_net_delayed_open(void *parm, u16 win, u16 ext)
+{
+ struct net_device *netdev = (struct net_device *)parm;
+ struct hf_net *net = netdev_priv(netdev);
+ struct hf_if *net_if = &(net->hfif);
+ int rc = 0;
+ struct hfidd_acs *p_acs = HF_ACS(net_if);
+
+ spin_lock(&(net_if->lock));
+ if (net_if->state != HF_NET_HALF_OPEN) {
+ netdev_err(netdev, "hf_net_delayed_open: net_if state=0x%x\n",
+ net_if->state);
+ spin_unlock(&(net_if->lock));
+ return -EINVAL;
+ }
+
+ rc = hf_alloc_resource(net);
+ if (rc)
+ goto delayed_open_err0;
+
+ rc = hf_open_ip_window(net, p_acs);
+ if (rc)
+ goto delayed_open_err1;
+
+ hf_set_mac_addr(netdev, NULL);
+
+ net_if->state = HF_NET_OPEN;
+ spin_unlock(&(net_if->lock));
+
+ return 0;
+
+delayed_open_err1:
+ hf_free_resource(net_if);
+
+delayed_open_err0:
+ spin_unlock(&(net_if->lock));
+
+ return rc;
+}
+
+static int hf_register_hfi_ready_callback(struct net_device *netdev,
+ struct hfidd_acs *p_acs,
+ int flag)
+{
+ struct hfi_reg_events reg_events;
+ int rc = 0;
+
+ reg_events.hdr.req = flag;
+ reg_events.hdr.req_len = sizeof(struct hfi_reg_events);
+ reg_events.hdr.result.use.kptr = NULL;
+ reg_events.type = FUNCTIONS_FOR_EVENTS;
+
+ reg_events.info.func.index = HFIDD_HFI_READY_REG;
+ reg_events.info.func.function_p.use.kptr = hf_net_delayed_open;
+ reg_events.info.func.parameter.use.kptr = (void *)(netdev);
+
+ if (flag == HFIDD_REQ_EVENT_REGISTER)
+ rc = hfidd_callback_register(p_acs, ®_events);
+ else
+ rc = hfidd_callback_unregister(p_acs, ®_events);
+ if (rc) {
+ netdev_err(netdev, "hf_register_hfi_ready_callback: fail"
+ " flag=0x%x rc=0x%x\n", flag, rc);
+
+ return rc;
+ }
+
+ return 0;
+}
+
+static int hf_net_open(struct net_device *netdev)
+{
+ struct hf_net *net = netdev_priv(netdev);
+ struct hf_if *net_if = &(net->hfif);
+ int rc = 0;
+ struct hfidd_acs *p_acs = HF_ACS(net_if);
+
+ memset(&(netdev->stats), 0, sizeof(struct net_device_stats));
+ net_if->sfifo_packets = 0;
+
+ spin_lock(&(net_if->lock));
+ net_if->state = HF_NET_HALF_OPEN;
+ spin_unlock(&(net_if->lock));
+
+ netif_carrier_off(netdev);
+
+ rc = hf_register_hfi_ready_callback(netdev, p_acs,
+ HFIDD_REQ_EVENT_REGISTER);
+ if (rc != 0) {
+ spin_lock(&(net_if->lock));
+ net_if->state = HF_NET_CLOSE;
+ spin_unlock(&(net_if->lock));
+
+ netdev_err(netdev, "hf_net_open: hf_register_hfi_ready_callback"
+ "fail, rc=0x%x, state=0x%x", rc, net_if->state);
+ return rc;
+ }
+
+ return 0;
+}
+
+static int hf_net_close(struct net_device *netdev)
+{
+ struct hf_net *net = netdev_priv(netdev);
+ struct hf_if *net_if = &(net->hfif);
+ struct hfidd_acs *p_acs = HF_ACS(net_if);
+
+ spin_lock(&(net_if->lock));
+ if (net_if->state == HF_NET_OPEN) {
+ hf_close_ip_window(net, p_acs);
+
+ hf_free_resource(net_if);
+ }
+
+ hf_register_hfi_ready_callback(netdev, p_acs,
+ HFIDD_REQ_EVENT_UNREGISTER);
+
+ net_if->state = HF_NET_CLOSE;
+ spin_unlock(&(net_if->lock));
+
+ return 0;
+}
+
+static int hf_change_mtu(struct net_device *netdev, int new_mtu)
+{
+ if ((new_mtu <= 68) || (new_mtu > HF_NET_MTU))
+ return -ERANGE;
+
+ netdev->mtu = new_mtu;
+
+ return 0;
+}
+
+static int hf_hard_header(struct sk_buff *skb,
+ struct net_device *netdev,
+ u16 type,
+ const void *daddr,
+ const void *saddr,
+ u32 len)
+{
+ struct ethhdr *hwhdr_p;
+
+ skb_push(skb, ETH_HLEN);
+
+ hwhdr_p = (struct ethhdr *)(skb->data);
+ hwhdr_p->h_proto = htons(type);
+
+ if (!saddr)
+ saddr = netdev->dev_addr;
+
+ memcpy(hwhdr_p->h_source, saddr, netdev->addr_len);
+
+ if (daddr) {
+ memcpy(hwhdr_p->h_dest, daddr, netdev->addr_len);
+ return netdev->hard_header_len;
+ }
+
+ if (netdev->flags & IFF_NOARP) {
+ memset(hwhdr_p->h_dest, 0, netdev->addr_len);
+ return netdev->hard_header_len;
+ }
+
+ return -netdev->hard_header_len;
+}
+
+static const struct header_ops hf_header_ops = {
+ .create = hf_hard_header,
+};
+
+static const struct net_device_ops hf_netdev_ops = {
+ .ndo_open = hf_net_open,
+ .ndo_stop = hf_net_close,
+ .ndo_change_mtu = hf_change_mtu,
+ .ndo_set_mac_address = NULL,
+};
+
+static void hf_if_setup(struct net_device *netdev)
+{
+ netdev->type = ARPHRD_HFI;
+ netdev->mtu = HF_NET_MTU;
+ netdev->tx_queue_len = 1000;
+ netdev->flags = IFF_BROADCAST;
+ netdev->hard_header_len = ETH_HLEN;
+ netdev->addr_len = ETH_ALEN;
+ netdev->needed_headroom = 0;
+
+ netdev->header_ops = &hf_header_ops;
+ netdev->netdev_ops = &hf_netdev_ops;
+
+ memcpy(netdev->broadcast, hfi_bcast_addr, ETH_ALEN);
+}
+
+static struct hf_net *hf_init_netdev(int idx, int ai)
+{
+ struct net_device *netdev;
+ struct hf_net *net;
+ int ii;
+ int rc;
+ char ifname[HF_MAX_NAME_LEN];
+
+ ii = (idx * MAX_HFIS) + ai;
+ sprintf(ifname, "hf%d", ii);
+ netdev = alloc_netdev(sizeof(struct hf_net), ifname, hf_if_setup);
+ if (!netdev) {
+ printk(KERN_ERR "hf_init_netdev: "
+ "alloc_netdev for hfi%d:hf%d fail\n", ai, idx);
+ return ERR_PTR(-ENODEV);
+ }
+
+ net = netdev_priv(netdev);
+ net->netdev = netdev;
+
+ memset(&(net->hfif), 0, sizeof(struct hf_if));
+ net->hfif.idx = ii; /* interface index */
+ net->hfif.ai = ai; /* adapter index */
+ strncpy(net->hfif.name, ifname, HF_MAX_NAME_LEN);
+ net->hfif.state = HF_NET_CLOSE;
+
+ spin_lock_init(&net->hfif.lock);
+
+ rc = register_netdev(netdev);
+ if (rc) {
+ netdev_err(netdev, "hf_init_netdev: "
+ "failed to register netdev=hfi%d:hf%d, "
+ "rc = 0x%x\n", ai, idx, rc);
+ free_netdev(netdev);
+ return ERR_PTR(-ENODEV);
+ }
+
+ return net;
+}
+
+static void hf_del_netdev(struct hf_net *net)
+{
+ struct net_device *netdev = net->netdev;
+
+ unregister_netdev(netdev);
+
+ free_netdev(netdev);
+}
+
+static int hf_inet_event(struct notifier_block *this,
+ unsigned long event,
+ void *ifa)
+{
+ struct in_device *in_dev;
+ struct net_device *netdev;
+
+ in_dev = ((struct in_ifaddr *)ifa)->ifa_dev;
+
+ netdev = in_dev->dev;
+
+ if (!net_eq(dev_net(netdev), &init_net))
+ return NOTIFY_DONE;
+
+ if ((event == NETDEV_UP) && (netdev->netdev_ops == &hf_netdev_ops)) {
+ struct hf_if *net_if;
+
+ net_if = &(((struct hf_net *)(netdev_priv(netdev)))->hfif);
+ net_if->ip_addr = ntohl(in_dev->ifa_list->ifa_address);
+ }
+
+ return NOTIFY_DONE;
+}
+
+static struct notifier_block hf_inet_notifier = {
+ .notifier_call = hf_inet_event,
+};
+
+static int __init hf_init_module(void)
+{
+ u32 idx, ai;
+ int rc;
+ struct hf_net *net;
+
+ memset(&hf_ginfo, 0, sizeof(struct hf_global_info));
+
+ for (idx = 0; idx < MAX_HF_PER_HFI; idx++) {
+ for (ai = 0; ai < MAX_HFIS; ai++) {
+ net = hf_init_netdev(idx, ai);
+ if (IS_ERR(net)) {
+ printk(KERN_ERR "hf_init_module: hf_init_netdev"
+ " for idx %d ai %d failed rc"
+ " %ld\n",
+ idx, ai, PTR_ERR(net));
+
+ goto err_out;
+ }
+
+ hf_ginfo.net[idx][ai] = net;
+ }
+ }
+
+ register_inetaddr_notifier(&hf_inet_notifier);
+
+ printk(KERN_INFO "hfi_ip module loaded\n");
+ return 0;
+
+err_out:
+ rc = PTR_ERR(net);
+ for (idx = 0; idx < MAX_HF_PER_HFI; idx++) {
+ for (ai = 0; ai < MAX_HFIS; ai++) {
+ net = hf_ginfo.net[idx][ai];
+ if (net != NULL) {
+ hf_del_netdev(net);
+ hf_ginfo.net[idx][ai] = NULL;
+ }
+ }
+ }
+
+ return rc;
+}
+
+static void __exit hf_cleanup_module(void)
+{
+ u32 idx, ai;
+ struct hf_net *net;
+
+ unregister_inetaddr_notifier(&hf_inet_notifier);
+ for (idx = 0; idx < MAX_HF_PER_HFI; idx++) {
+ for (ai = 0; ai < MAX_HFIS; ai++) {
+
+ net = hf_ginfo.net[idx][ai];
+ if (net != NULL) {
+ hf_del_netdev(net);
+ hf_ginfo.net[idx][ai] = NULL;
+ }
+ }
+ }
+
+ return;
+}
+
+module_init(hf_init_module);
+module_exit(hf_cleanup_module);
diff --git a/include/linux/hfi/hfi_ip.h b/include/linux/hfi/hfi_ip.h
new file mode 100644
index 0000000..6b6a74c
--- /dev/null
+++ b/include/linux/hfi/hfi_ip.h
@@ -0,0 +1,148 @@
+/*
+ * hfi_ip.h
+ *
+ * HF IP driver for IBM System p
+ *
+ * Authors:
+ * Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
+ * William S. Cadden <wscadden@linux.vnet.ibm.com>
+ * Wen C. Chen <wcchen@linux.vnet.ibm.com>
+ * Scot Sakolish <sakolish@linux.vnet.ibm.com>
+ * Jian Xiao <jian@linux.vnet.ibm.com>
+ * Carol L. Soto <clsoto@linux.vnet.ibm.com>
+ * Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
+ *
+ * (C) Copyright IBM Corp. 2010
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#ifndef _HFI_IP_H_
+#define _HFI_IP_H_
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/netdevice.h>
+#include <linux/inetdevice.h>
+#include <net/arp.h>
+
+#include <linux/hfi/hfidd_internal.h>
+#include <linux/hfi/hfidd_client.h>
+#include <linux/hfi/hfidd_requests.h>
+#include <linux/hfi/hfidd_pkt_formats.h>
+
+#define HF_DRV_VERSION "1.0"
+#define HF_DRV_RELDATE "July 7, 2010"
+#define HF_DRV_NAME "hf"
+
+#define MAX_HF_PER_HFI 2
+#define HF_IP_JOBID 0xFFFFFFF0
+#define HF_MAX_NAME_LEN 64
+
+#define HF_SFIFO_SIZE 0x40000 /* 256K */
+#define HF_SFIFO_SLOTS (HF_SFIFO_SIZE >> HFI_CACHE_LINE_SHIFT)
+#define HF_RFIFO_SIZE 0x1000000 /* 16M */
+#define HF_RFIFO_SLOTS (HF_RFIFO_SIZE >> HFI_CACHE_LINE_SHIFT)
+
+#define HF_FV_BIT_CNT 32
+
+#define HF_NET_MTU (2048 - HF_IP_HDR_LEN - HF_PROTO_LEN)
+
+struct hfi_ip_extended_hdr { /* 16B */
+ unsigned int immediate_len:7;/* In bytes */
+ unsigned int num_desc:3; /* number of descriptors */
+ /* Logical Port ID: */
+ unsigned int lpid_valid:1; /* set by sending HFI */
+ unsigned int lpid:4; /* set by sending HFI */
+ /* Ethernet Service Header is 113 bits, which is 14 bytes + 1 bit */
+ unsigned int ethernet_svc_hdr_hi:1; /* Not used by HFI */
+ char ethernet_svc_hdr[12]; /* Not used by HFI */
+ __sum16 bcast_csum;
+} __packed;
+
+struct hfi_ip_with_payload_pkt {
+ struct hfi_hdr hfi_hdr;
+ struct hfi_ip_extended_hdr ip_ext;
+ char payload[2016];
+} __packed;
+
+#define HF_IP_HDR_LEN ((sizeof(struct hfi_hdr) + \
+ sizeof(struct hfi_ip_extended_hdr)))
+#define HF_ALIGN_PAD 2
+
+struct hf_if_proto_hdr {
+ u16 version;
+ u8 msg_type;
+ u8 msg_flag;
+ u32 msg_len; /* Include HFI header */
+ u32 msg_id;
+};
+
+#define HF_PROTO_LEN sizeof(struct hf_if_proto_hdr)
+
+struct hf_fifo {
+ void *addr;
+ u32 size; /* total bytes */
+ u32 head;
+ u32 tail;
+ u32 emax; /* power 2 mask */
+ atomic_t avail; /* for tx */
+ atomic_t outstanding; /* for rx */
+};
+
+#define HF_NET_CLOSE 0x00
+#define HF_NET_HALF_OPEN 0xA0
+#define HF_NET_OPEN 0xA1
+
+struct hf_if {
+ u32 idx; /* 0, 1, 2, 3 ... */
+ u32 ai; /* 0=hfi0, 1=hfi1 */
+ char name[HF_MAX_NAME_LEN];
+ u32 isr_id;
+ u32 ip_addr;
+ u32 state; /* CLOSE, OPEN */
+ spinlock_t lock; /* lock for state */
+ u32 sfifo_fv_polarity;
+ u32 sfifo_slots_per_blk;
+ u32 sfifo_packets;
+ void __iomem *doorbell; /* mapped mmio_regs */
+ struct hf_fifo tx_fifo;
+ struct hf_fifo rx_fifo;
+ struct hfi_client_info client;
+ struct sk_buff **tx_skb; /* array to store tx
+ 2k skb */
+ void *sfifo_finishvec;
+};
+
+/* Private structure for HF inetrface */
+struct hf_net {
+ struct net_device *netdev;
+ struct hf_if hfif;
+};
+
+extern struct hfidd_global hfidd_global;
+
+#define HF_ACS(net_if) (hfidd_global.p_acs[(net_if)->ai])
+
+struct hf_global_info {
+ struct hf_net *net[MAX_HF_PER_HFI][MAX_HFI_PER_TORRENT];
+};
+
+extern struct hf_global_info hf_ginfo;
+
+#define HF_MAC_HFI_SHIFT 12
+#endif
diff --git a/include/linux/if_arp.h b/include/linux/if_arp.h
index 6d722f4..f2cfdc1 100644
--- a/include/linux/if_arp.h
+++ b/include/linux/if_arp.h
@@ -41,6 +41,7 @@
#define ARPHRD_IEEE1394 24 /* IEEE 1394 IPv4 - RFC 2734 */
#define ARPHRD_EUI64 27 /* EUI-64 */
#define ARPHRD_INFINIBAND 32 /* InfiniBand */
+#define ARPHRD_HFI 37 /* Host Fabric Interface */
/* Dummy types for non ARP hardware */
#define ARPHRD_SLIP 256
--
1.7.3.5
^ permalink raw reply related
* [PATCH v2 25/27] HFI: hfi_ip fifo transmit paths
From: dykmanj @ 2011-04-18 3:21 UTC (permalink / raw)
To: netdev
Cc: Jim Dykman, Piyush Chaudhary, Fu-Chung Chang, William S. Cadden,
Wen C. Chen, Scot Sakolish, Jian Xiao, Carol L. Soto,
Sarah J. Sheppard
In-Reply-To: <1303096919-7367-1-git-send-email-dykmanj@linux.vnet.ibm.com>
From: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Piyush Chaudhary <piyushc@linux.vnet.ibm.com>
Signed-off-by: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
Signed-off-by: William S. Cadden <wscadden@linux.vnet.ibm.com>
Signed-off-by: Wen C. Chen <winstonc@linux.vnet.ibm.com>
Signed-off-by: Scot Sakolish <sakolish@linux.vnet.ibm.com>
Signed-off-by: Jian Xiao <jian@linux.vnet.ibm.com>
Signed-off-by: Carol L. Soto <clsoto@linux.vnet.ibm.com>
Signed-off-by: Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
---
drivers/net/hfi/ip/hf_proto.h | 1 +
drivers/net/hfi/ip/hfi_ip_main.c | 438 ++++++++++++++++++++++++++++++++++++++
include/linux/hfi/hfi_ip.h | 72 ++++++-
3 files changed, 510 insertions(+), 1 deletions(-)
diff --git a/drivers/net/hfi/ip/hf_proto.h b/drivers/net/hfi/ip/hf_proto.h
index b4133b7..b0232ab 100644
--- a/drivers/net/hfi/ip/hf_proto.h
+++ b/drivers/net/hfi/ip/hf_proto.h
@@ -33,6 +33,7 @@
#ifndef _HF_PROTO_H_
#define _HF_PROTO_H_
+int hf_tx_check_avail(struct hf_net *net, u32 xmit_cls);
extern int hfidd_open_window_func(struct hfidd_acs *p_acs,
u32 is_userspace,
struct hfi_client_info *user_p,
diff --git a/drivers/net/hfi/ip/hfi_ip_main.c b/drivers/net/hfi/ip/hfi_ip_main.c
index 0c1ebd7..689f92e 100644
--- a/drivers/net/hfi/ip/hfi_ip_main.c
+++ b/drivers/net/hfi/ip/hfi_ip_main.c
@@ -185,6 +185,87 @@ alloc_resource_err0:
return rc;
}
+static int hf_send_intr_callback(void *parm, u32 win, u32 ext)
+{
+ struct hf_net *net = (struct hf_net *)parm;
+ struct hf_if *net_if = &(net->hfif);
+ u64 sintr_status;
+
+ sintr_status = hf_mmio_regs_read(net_if, HFI_SINTR_STATUS_REG);
+
+ netdev_info(net->netdev, "hf_send_intr_callback: "
+ "sintr_status 0x%016llx", sintr_status);
+
+ /* mask off the interrupt */
+ if (sintr_status & HF_SFIFO_INTR_EVENT)
+ hf_mmio_regs_write(net_if, HFI_SFIFO_INTR_CNTL, 0);
+
+ /* Make sure interrupts are masked */
+ /* Otherwise after the queue is awaken, it will get stale interrupt */
+ mb();
+
+ netif_wake_queue(net->netdev);
+
+ return 0;
+}
+
+struct hf_events_cb hf_events[HF_EVENT_NUM] = {
+ {HFIDD_SEND, (void *)hf_send_intr_callback},
+};
+
+static int hf_register_ip_events(struct hf_net *net,
+ struct hfidd_acs *p_acs,
+ int flag)
+{
+ struct hf_if *net_if = &(net->hfif);
+ int rc = 0, i, j;
+ struct hfi_reg_events events[HF_EVENT_NUM];
+ int (*reg_func)(struct hfidd_acs *,
+ struct hfi_reg_events *);
+
+ if (flag == HFIDD_REQ_EVENT_REGISTER)
+ reg_func = hfidd_callback_register;
+ else
+ reg_func = hfidd_callback_unregister;
+
+ for (i = 0; i < HF_EVENT_NUM; i++) {
+ events[i].window = net_if->client.window;
+ events[i].type = FUNCTIONS_FOR_EVENTS;
+ events[i].info.func.index = hf_events[i].type;
+ events[i].info.func.function_p.use.kptr = hf_events[i].func;
+ events[i].info.func.parameter.use.kptr = (void *)(net);
+
+ events[i].hdr.req = flag;
+ events[i].hdr.req_len = sizeof(struct hfi_reg_events);
+ events[i].hdr.result.use.kptr = &(events[i]);
+
+ rc = reg_func(p_acs, &(events[i]));
+ if (rc) {
+ netdev_err(net->netdev, "hf_register_ip_events: "
+ "fail event 0x%x, flag=0x%x rc=0x%x\n",
+ hf_events[i].type, flag, rc);
+
+ if (flag == HFIDD_REQ_EVENT_REGISTER)
+ goto err_out;
+ }
+ }
+
+ return rc;
+
+err_out:
+ for (j = 0; j < i; j++) {
+ events[j].hdr.req = HFIDD_REQ_EVENT_UNREGISTER;
+ rc = hfidd_callback_unregister(p_acs, &(events[i]));
+ if (rc) {
+ netdev_err(net->netdev, "hf_register_ip_events: failed "
+ "to unregister callback event 0x%x, rc=0x%x\n",
+ events[i].info.func.index, rc);
+ }
+ }
+
+ return rc;
+}
+
static int hf_close_ip_window(struct hf_net *net, struct hfidd_acs *p_acs)
{
struct hf_if *net_if = &(net->hfif);
@@ -276,6 +357,16 @@ static int hf_set_mac_addr(struct net_device *netdev, void *p)
return 0;
}
+static void hf_init_hw_regs(struct hf_if *net_if)
+{
+ /* setup IP with payload threshold in cache line size */
+ hf_mmio_regs_write(net_if, HFI_IP_RECV_SIZE,
+ (HF_PAYLOAD_RX_THRESHOLD << HF_PAYLOAD_RX_THRESH_SHIFT));
+
+ /* initialize SEND INTR STATUS */
+ hf_mmio_regs_write(net_if, HFI_SINTR_STATUS_REG, 0);
+}
+
static int hf_net_delayed_open(void *parm, u16 win, u16 ext)
{
struct net_device *netdev = (struct net_device *)parm;
@@ -300,13 +391,25 @@ static int hf_net_delayed_open(void *parm, u16 win, u16 ext)
if (rc)
goto delayed_open_err1;
+ rc = hf_register_ip_events(net, p_acs, HFIDD_REQ_EVENT_REGISTER);
+ if (rc)
+ goto delayed_open_err2;
+
hf_set_mac_addr(netdev, NULL);
+ hf_init_hw_regs(net_if);
+
net_if->state = HF_NET_OPEN;
spin_unlock(&(net_if->lock));
+ netif_carrier_on(netdev);
+ netif_start_queue(netdev);
+
return 0;
+delayed_open_err2:
+ hf_close_ip_window(net, p_acs);
+
delayed_open_err1:
hf_free_resource(net_if);
@@ -385,6 +488,11 @@ static int hf_net_close(struct net_device *netdev)
spin_lock(&(net_if->lock));
if (net_if->state == HF_NET_OPEN) {
+ netif_stop_queue(netdev);
+ netif_carrier_off(netdev);
+
+ hf_register_ip_events(net, p_acs, HFIDD_REQ_EVENT_UNREGISTER);
+
hf_close_ip_window(net, p_acs);
hf_free_resource(net_if);
@@ -399,6 +507,332 @@ static int hf_net_close(struct net_device *netdev)
return 0;
}
+static void hf_tx_recycle(struct hf_if *net_if)
+{
+ u32 head, head_idx, slots_per_blk;
+ u32 *fv;
+ int i;
+ u32 fv_bit;
+ u8 nr;
+
+ head = net_if->tx_fifo.head;
+
+ slots_per_blk = net_if->sfifo_slots_per_blk;
+
+ head_idx = head / slots_per_blk;
+
+ fv = (u32 *)(net_if->sfifo_finishvec);
+
+ while (1) {
+ nr = HF_FV_BIT_MAX - head_idx;
+ fv_bit = BIT(nr) & (ACCESS_ONCE(*fv));
+ fv_bit = fv_bit >> nr;
+
+ if ((fv_bit ^ (net_if->sfifo_fv_polarity)) == 0)
+ break;
+
+ for (i = 0; i < slots_per_blk; i++) {
+ struct sk_buff *skb;
+
+ skb = net_if->tx_skb[head + i];
+ if (skb != NULL) {
+ dev_kfree_skb_any(skb);
+ net_if->tx_skb[head + i] = NULL;
+ }
+ }
+
+ head = (head + slots_per_blk) & (net_if->tx_fifo.emax);
+
+ atomic_add(slots_per_blk, &(net_if->tx_fifo.avail));
+
+ if (++head_idx == HF_FV_BIT_CNT) {
+ head_idx = 0;
+ net_if->sfifo_fv_polarity ^= 1;
+ }
+ }
+
+ net_if->tx_fifo.head = head;
+
+ return;
+}
+
+int hf_tx_check_avail(struct hf_net *net, u32 xmit_cls)
+{
+ struct net_device *netdev = net->netdev;
+ struct hf_if *net_if = &(net->hfif);
+
+ if (atomic_read(&net_if->tx_fifo.avail) < xmit_cls) {
+
+ hf_tx_recycle(net_if);
+
+ if (atomic_read(&net_if->tx_fifo.avail) < xmit_cls) {
+ u32 intr_cntl;
+ u64 intr_thresh;
+
+ netif_stop_queue(netdev);
+
+ /* turn on transmit interrupt */
+ intr_thresh = (net_if->sfifo_packets -
+ HF_SFIFO_INTR_WATERMARK) & HF_SFIFO_INTR_MASK;
+
+ intr_cntl = HF_SFIFO_INTR_ENABLE |
+ (intr_thresh << HF_SFIFO_INTR_CNT_SHIFT);
+
+ hf_mmio_regs_write_then_read(net_if,
+ HFI_SFIFO_INTR_CNTL, intr_cntl);
+
+ return -EBUSY;
+ }
+ }
+
+ return 0;
+}
+
+static inline void hf_fill_route(u16 dst_isr, struct base_hdr *base_hdr_p)
+{
+ base_hdr_p->route_control = HFI_HW_DIRECT_ROUTE;
+}
+
+static int hf_copy_skb_to_fifo(struct hf_net *net,
+ struct sk_buff *skb,
+ char *dst,
+ u32 len,
+ u32 offset)
+{
+ struct hf_if *net_if = &(net->hfif);
+ u64 fifo_end;
+ u32 tail_room;
+ int rc;
+
+ fifo_end = (u64)(net_if->tx_fifo.addr) + net_if->tx_fifo.size;
+
+ tail_room = fifo_end - (u64)dst;
+ if (tail_room >= len) {
+ rc = skb_copy_bits(skb, offset, dst, len);
+ if (rc) {
+ netdev_err(net->netdev,
+ "hf_copy_skb_to_fifo: skb_copy_bits"
+ "fail1 offset=0x%x, len=0x%x, rc=0x%x\n",
+ offset, len, rc);
+ return rc;
+ }
+ } else {
+ rc = skb_copy_bits(skb, offset, dst, tail_room);
+ if (rc) {
+ netdev_err(net->netdev,
+ "hf_copy_skb_to_fifo: skb_copy_bits"
+ "fail2 offset=0x%x, len=0x%x, rc=0x%x\n",
+ offset, tail_room, rc);
+
+ return rc;
+ }
+ rc = skb_copy_bits(skb, offset + tail_room,
+ net_if->tx_fifo.addr, len - tail_room);
+ if (rc) {
+ netdev_err(net->netdev,
+ "hf_copy_skb_to_fifo: skb_copy_bits"
+ "fail3 offset=0x%x, len=0x%x, rc=0x%x\n",
+ offset + tail_room, len - tail_room, rc);
+
+ return rc;
+ }
+ }
+
+ return 0;
+}
+
+/* Build base_hdr and proto_hdr for payload pkt.
+ Return pointer to the end of proto_hdr */
+static char *hf_build_payload_hdr(struct hf_net *net,
+ struct sk_buff *skb,
+ u32 msg_len,
+ u32 xmit_cls,
+ u32 is_bcast)
+{
+ struct hf_if *net_if = &(net->hfif);
+ struct hf_if_proto_hdr *proto_hdr_p;
+ struct hfi_ip_with_payload_pkt *hdr_p;
+ char *dst;
+ u8 msg_type, msg_flag;
+ struct ethhdr *hwhdr_p;
+
+ hwhdr_p = (struct ethhdr *)(skb->data);
+
+ if (hwhdr_p->h_proto == htons(ETH_P_IP))
+ msg_type = HF_IF_FIFO;
+ else if (hwhdr_p->h_proto == htons(ETH_P_ARP))
+ msg_type = HF_IF_ARP;
+ else {
+ netdev_err(net->netdev, "hf_build_payload_hdr: h_proto = 0x%x "
+ " not supported\n", hwhdr_p->h_proto);
+
+ dev_kfree_skb_any(skb);
+ return NULL;
+ }
+
+ dst = net_if->tx_fifo.addr +
+ (net_if->tx_fifo.tail << HFI_CACHE_LINE_SHIFT);
+
+ /* fill in base_hdr + ip_extended_hdr */
+ hdr_p = (struct hfi_ip_with_payload_pkt *)dst;
+
+ /* Do not memset over one cacheline since it might wrap */
+ memset(hdr_p, 0, HF_IP_HDR_LEN);
+
+ hdr_p->hfi_hdr.type.header_type = HFI_IP_WITH_PAYLOAD;
+ hdr_p->hfi_hdr.id.job_id = net_if->client.job_id;
+
+ if (is_bcast) {
+ hdr_p->hfi_hdr.base_hdr.dst_isr = HFIDD_DST_BCST_ISR;
+ hdr_p->hfi_hdr.base_hdr.dst_win = HFIDD_DST_BCST_WIN;
+ hdr_p->hfi_hdr.type.header_type = HFI_IP_MULTICAST_WITH_PAYLOAD;
+
+ msg_flag = HF_IF_BCAST;
+ } else {
+ u16 dst_isr, dst_win;
+
+ hf_get_dst_info(hwhdr_p, &dst_isr, &dst_win);
+ hdr_p->hfi_hdr.base_hdr.dst_isr = dst_isr;
+ hdr_p->hfi_hdr.base_hdr.dst_win = dst_win;
+
+ hf_fill_route(dst_isr, &(hdr_p->hfi_hdr.base_hdr));
+
+ msg_flag = HF_IF_UCAST;
+ }
+
+ netdev_dbg(net->netdev, "hf_build_payload_hdr: dst_isr = 0x%x, "
+ "dst_win = 0x%x, xmit_cls = 0x%x\n",
+ hdr_p->hfi_hdr.base_hdr.dst_isr,
+ hdr_p->hfi_hdr.base_hdr.dst_win, xmit_cls);
+
+ hdr_p->hfi_hdr.base_hdr.pkt_len = hfi_cachelines_to_pktlen(xmit_cls);
+
+ dst += HF_IP_HDR_LEN;
+ proto_hdr_p = (struct hf_if_proto_hdr *)dst;
+
+ proto_hdr_p->version = HF_PROTO_HDR_VERSION;
+ proto_hdr_p->msg_len = msg_len;
+ proto_hdr_p->msg_id = net_if->msg_id;
+ proto_hdr_p->msg_type = msg_type;
+ proto_hdr_p->msg_flag = msg_flag;
+
+ dst += HF_PROTO_LEN;
+
+ return dst;
+}
+
+static int hf_payload_tx(struct sk_buff *skb, struct hf_net *net, u32 is_bcast)
+{
+ struct hf_if *net_if = &(net->hfif);
+ u32 msg_len, len;
+ u32 xmit_cls;
+ char *dst;
+ int rc = 0;
+
+ msg_len = skb->len - ETH_HLEN + HF_PROTO_LEN;
+ xmit_cls = hfi_bytes_to_cacheline(msg_len + HF_IP_HDR_LEN);
+
+ if (is_bcast) {
+ if (xmit_cls <= HF_BCAST_CACHE_LINE_2)
+ xmit_cls = HF_BCAST_CACHE_LINE_2;
+ else
+ xmit_cls = HF_BCAST_CACHE_LINE_16;
+ }
+
+ rc = hf_tx_check_avail(net, xmit_cls);
+ if (rc) {
+ netdev_err(net->netdev, "hf_payload_tx: hf_tx_check_avail find "
+ "no avail slot\n");
+ return rc;
+ }
+
+ dst = hf_build_payload_hdr(net, skb, msg_len, xmit_cls, is_bcast);
+ if (!dst)
+ return 0;
+
+ /* copy skb data, skipping hwhdr */
+ len = skb->len - ETH_HLEN;
+
+ rc = hf_copy_skb_to_fifo(net, skb, dst, len, ETH_HLEN);
+ if (rc)
+ return rc;
+
+ net_if->tx_fifo.tail =
+ (net_if->tx_fifo.tail + xmit_cls) & (net_if->tx_fifo.emax);
+ atomic_sub(xmit_cls, &(net_if->tx_fifo.avail));
+
+ net_if->sfifo_packets++;
+ net->netdev->stats.tx_packets++;
+ net->netdev->stats.tx_bytes += msg_len;
+
+ netdev_dbg(net->netdev, "hf_payload_tx: exit, tx_fifo tail = 0x%x, "
+ "avail = 0x%x, skb->len = 0x%x\n", net_if->tx_fifo.tail,
+ atomic_read(&(net_if->tx_fifo.avail)), skb->len);
+
+ dev_kfree_skb_any(skb);
+ return 0;
+
+}
+
+static int hf_start_xmit(struct sk_buff *skb, struct net_device *netdev)
+{
+ struct hf_net *net = netdev_priv(netdev);
+ struct hf_if *net_if = &(net->hfif);
+ u32 len, is_bcast;
+ u32 send_cnt = 1;
+
+ is_bcast = !memcmp(((struct ethhdr *)(skb->data))->h_dest,
+ netdev->broadcast,
+ netdev->addr_len);
+
+ if (unlikely(skb->len <= 0)) {
+ netdev_err(netdev, "hf_start_xmit: invalid skb->len 0x%x\n",
+ skb->len);
+ dev_kfree_skb_any(skb);
+ return NETDEV_TX_OK;
+ }
+
+ /* total len to transfer */
+ len = skb->len - ETH_HLEN;
+
+ if (len <= HF_PAYLOAD_MAX) {
+ /* send ip with payload */
+ if (hf_payload_tx(skb, net, is_bcast) < 0) {
+ netdev_err(netdev, "hf_start_xmit: "
+ "hf_payload_tx fail 1\n");
+
+ return NETDEV_TX_BUSY;
+ }
+ } else {
+ netdev_err(netdev, "hf_start_xmit: skb->len 0x%x "
+ "greater than max 0x%x\n",
+ skb->len, (u32)HF_PAYLOAD_MAX);
+
+ dev_kfree_skb_any(skb);
+ return NETDEV_TX_OK;
+ }
+
+ /* Make sure all fields are written before ringing hw doorbell */
+ wmb();
+
+ /* ring doorbell */
+ hf_mmio_regs_write(net_if, HFI_SFIFO_DB_REG, send_cnt);
+
+ if (atomic_read(&net_if->tx_fifo.avail) < HF_TX_LOW_WATERMARK)
+ hf_tx_check_avail(net, HF_TX_LOW_WATERMARK);
+
+ net_if->msg_id++;
+ netdev->trans_start = jiffies;
+
+ return NETDEV_TX_OK;
+}
+
+static void hf_tx_timeout(struct net_device *netdev)
+{
+ netdev_warn(netdev, "hf_tx_timeout: queue_stopped is %d\n",
+ netif_queue_stopped(netdev));
+}
+
static int hf_change_mtu(struct net_device *netdev, int new_mtu)
{
if ((new_mtu <= 68) || (new_mtu > HF_NET_MTU))
@@ -449,6 +883,8 @@ static const struct net_device_ops hf_netdev_ops = {
.ndo_open = hf_net_open,
.ndo_stop = hf_net_close,
.ndo_change_mtu = hf_change_mtu,
+ .ndo_start_xmit = hf_start_xmit,
+ .ndo_tx_timeout = hf_tx_timeout,
.ndo_set_mac_address = NULL,
};
@@ -465,6 +901,8 @@ static void hf_if_setup(struct net_device *netdev)
netdev->header_ops = &hf_header_ops;
netdev->netdev_ops = &hf_netdev_ops;
+ netdev->watchdog_timeo = HF_TX_TIMEOUT;
+
memcpy(netdev->broadcast, hfi_bcast_addr, ETH_ALEN);
}
diff --git a/include/linux/hfi/hfi_ip.h b/include/linux/hfi/hfi_ip.h
index 6b6a74c..4e70c14 100644
--- a/include/linux/hfi/hfi_ip.h
+++ b/include/linux/hfi/hfi_ip.h
@@ -43,6 +43,7 @@
#include <linux/hfi/hfidd_internal.h>
#include <linux/hfi/hfidd_client.h>
#include <linux/hfi/hfidd_requests.h>
+#include <linux/hfi/hfidd_regs.h>
#include <linux/hfi/hfidd_pkt_formats.h>
#define HF_DRV_VERSION "1.0"
@@ -51,16 +52,32 @@
#define MAX_HF_PER_HFI 2
#define HF_IP_JOBID 0xFFFFFFF0
+#define HF_TX_TIMEOUT (500 * HZ)
+#define HF_NAPI_WEIGHT 256
#define HF_MAX_NAME_LEN 64
+/* sfifo intr: bit 39-55 is threshold */
+/* bit 34 enable, bit 35 unmask */
+#define HF_SFIFO_INTR_ENABLE (0x3 << (63 - 35))
+#define HF_SFIFO_INTR_MASK 0x1FFFF /* 17 bits */
+#define HF_SFIFO_INTR_CNT_SHIFT (63 - 55)
+#define HF_SFIFO_INTR_EVENT 0x00000040 /* bit 57 */
+#define HF_SFIFO_INTR_WATERMARK (HF_SFIFO_SLOTS - (HF_SFIFO_SLOTS >> 3))
+
#define HF_SFIFO_SIZE 0x40000 /* 256K */
#define HF_SFIFO_SLOTS (HF_SFIFO_SIZE >> HFI_CACHE_LINE_SHIFT)
#define HF_RFIFO_SIZE 0x1000000 /* 16M */
#define HF_RFIFO_SLOTS (HF_RFIFO_SIZE >> HFI_CACHE_LINE_SHIFT)
+#define HF_TX_LOW_WATERMARK (HF_SFIFO_SLOTS >> 4)
#define HF_FV_BIT_CNT 32
+#define HF_FV_BIT_MAX 31
+#define HF_SEND_ONE 1
-#define HF_NET_MTU (2048 - HF_IP_HDR_LEN - HF_PROTO_LEN)
+#define HF_PAYLOAD_MAX (2048 - HF_IP_HDR_LEN - HF_PROTO_LEN)
+#define HF_NET_MTU HF_PAYLOAD_MAX
+#define HF_PAYLOAD_RX_THRESHOLD 0x10ULL
+#define HF_PAYLOAD_RX_THRESH_SHIFT 59
struct hfi_ip_extended_hdr { /* 16B */
unsigned int immediate_len:7;/* In bytes */
@@ -83,6 +100,14 @@ struct hfi_ip_with_payload_pkt {
#define HF_IP_HDR_LEN ((sizeof(struct hfi_hdr) + \
sizeof(struct hfi_ip_extended_hdr)))
#define HF_ALIGN_PAD 2
+#define HF_PROTO_HDR_VERSION 0x1
+/* HFI protocol message type */
+#define HF_IF_ARP 0xA0
+#define HF_IF_FIFO 0xA1
+
+/* HFI protocol message flag */
+#define HF_IF_UCAST 0xB0
+#define HF_IF_BCAST 0xB1
struct hf_if_proto_hdr {
u16 version;
@@ -93,6 +118,8 @@ struct hf_if_proto_hdr {
};
#define HF_PROTO_LEN sizeof(struct hf_if_proto_hdr)
+#define HF_BCAST_CACHE_LINE_16 16
+#define HF_BCAST_CACHE_LINE_2 2
struct hf_fifo {
void *addr;
@@ -119,6 +146,7 @@ struct hf_if {
u32 sfifo_fv_polarity;
u32 sfifo_slots_per_blk;
u32 sfifo_packets;
+ u32 msg_id;
void __iomem *doorbell; /* mapped mmio_regs */
struct hf_fifo tx_fifo;
struct hf_fifo rx_fifo;
@@ -144,5 +172,47 @@ struct hf_global_info {
extern struct hf_global_info hf_ginfo;
+#define HF_EVENT_NUM 1
+
+struct hf_events_cb {
+ enum hfi_event_type type;
+ void *func;
+};
+
#define HF_MAC_HFI_SHIFT 12
+#define HF_HDR_HFI_SHIFT 8
+
+static inline u32 hf_get_win(u16 id)
+{
+ return ((id >> HF_MAC_HFI_SHIFT) << HF_HDR_HFI_SHIFT) | (id & 0xFF);
+}
+
+static inline void hf_get_dst_info(struct ethhdr *hwhdr_p,
+ u16 *d_isr,
+ u16 *d_win)
+{
+ *d_isr = (*(u16 *)(&(hwhdr_p->h_dest[2]))) & 0xFFF;
+ *d_win = hf_get_win(*(u16 *)(&(hwhdr_p->h_dest[4])));
+}
+
+static inline void hf_mmio_regs_write_then_read(struct hf_if *net_if,
+ int off,
+ u64 data)
+{
+ __raw_writeq(data, net_if->doorbell + off);
+ isync();
+ __raw_readq(net_if->doorbell + off);
+ /* Make sure all received pkt shows up in rfifo */
+ mb();
+}
+
+static inline u64 hf_mmio_regs_read(struct hf_if *net_if, int off)
+{
+ return __raw_readq(net_if->doorbell + off);
+}
+
+static inline void hf_mmio_regs_write(struct hf_if *net_if, int off, u64 data)
+{
+ __raw_writeq(data, net_if->doorbell + off);
+}
#endif
--
1.7.3.5
^ permalink raw reply related
* [PATCH v2 26/27] HFI: hfi_ip fifo receive path
From: dykmanj @ 2011-04-18 3:21 UTC (permalink / raw)
To: netdev
Cc: Jim Dykman, Piyush Chaudhary, Fu-Chung Chang, William S. Cadden,
Wen C. Chen, Scot Sakolish, Jian Xiao, Carol L. Soto,
Sarah J. Sheppard
In-Reply-To: <1303096919-7367-1-git-send-email-dykmanj@linux.vnet.ibm.com>
From: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Piyush Chaudhary <piyushc@linux.vnet.ibm.com>
Signed-off-by: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
Signed-off-by: William S. Cadden <wscadden@linux.vnet.ibm.com>
Signed-off-by: Wen C. Chen <winstonc@linux.vnet.ibm.com>
Signed-off-by: Scot Sakolish <sakolish@linux.vnet.ibm.com>
Signed-off-by: Jian Xiao <jian@linux.vnet.ibm.com>
Signed-off-by: Carol L. Soto <clsoto@linux.vnet.ibm.com>
Signed-off-by: Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
---
drivers/net/hfi/ip/hf_proto.h | 2 +
drivers/net/hfi/ip/hfi_ip_main.c | 326 +++++++++++++++++++++++++++++++++++++-
include/linux/hfi/hfi_ip.h | 26 +++-
3 files changed, 351 insertions(+), 3 deletions(-)
diff --git a/drivers/net/hfi/ip/hf_proto.h b/drivers/net/hfi/ip/hf_proto.h
index b0232ab..022512a 100644
--- a/drivers/net/hfi/ip/hf_proto.h
+++ b/drivers/net/hfi/ip/hf_proto.h
@@ -34,6 +34,8 @@
#define _HF_PROTO_H_
int hf_tx_check_avail(struct hf_net *net, u32 xmit_cls);
+void hf_construct_hwhdr(struct hf_if *net_if, struct sk_buff *skb,
+ struct base_hdr *b_hdr);
extern int hfidd_open_window_func(struct hfidd_acs *p_acs,
u32 is_userspace,
struct hfi_client_info *user_p,
diff --git a/drivers/net/hfi/ip/hfi_ip_main.c b/drivers/net/hfi/ip/hfi_ip_main.c
index 689f92e..6b2ec3f 100644
--- a/drivers/net/hfi/ip/hfi_ip_main.c
+++ b/drivers/net/hfi/ip/hfi_ip_main.c
@@ -154,6 +154,9 @@ static int hf_alloc_rx_resource(struct hf_net *net)
memset(net_if->rx_fifo.addr, 0, net_if->rx_fifo.size);
+ net_if->rx_fslot_debt = 0;
+ net_if->rx_pkt_valid = 1;
+
return 0;
}
@@ -209,8 +212,18 @@ static int hf_send_intr_callback(void *parm, u32 win, u32 ext)
return 0;
}
+static int hf_recv_intr_callback(void *parm, u32 win, u32 ext)
+{
+ struct hf_net *net = (struct hf_net *)parm;
+
+ napi_schedule(&(net->napi));
+
+ return 0;
+}
+
struct hf_events_cb hf_events[HF_EVENT_NUM] = {
{HFIDD_SEND, (void *)hf_send_intr_callback},
+ {HFIDD_RECV, (void *)hf_recv_intr_callback},
};
static int hf_register_ip_events(struct hf_net *net,
@@ -357,14 +370,50 @@ static int hf_set_mac_addr(struct net_device *netdev, void *p)
return 0;
}
+static void hf_set_recv_intr(struct hf_if *net_if)
+{
+ int offset;
+ struct hfi_hdr *rx_pkt;
+
+ /* enable recv intr and set threshold to next packet */
+ offset = net_if->rx_fifo.head;
+
+ hf_mmio_regs_write_then_read(net_if, HFI_RFIFO_INTR_REG,
+ (HF_ENA_RECV_INTR + (offset << HF_RECV_INTR_MATCH_SHIFT)));
+
+ /* check if there is packet received in the mean time */
+ rx_pkt = net_if->rx_fifo.addr + (offset << HFI_CACHE_LINE_SHIFT);
+
+ if ((rx_pkt->id.job_id == HF_IP_JOBID) &&
+ (rx_pkt->base_hdr.pkt_valid == net_if->rx_pkt_valid)) {
+
+ /* force an immediate recv intr */
+ hf_mmio_regs_write(net_if, HFI_RFIFO_INTR_REG,
+ (HF_IMM_RECV_INTR + (offset << HF_RECV_INTR_MATCH_SHIFT)));
+ }
+}
+
static void hf_init_hw_regs(struct hf_if *net_if)
{
/* setup IP with payload threshold in cache line size */
hf_mmio_regs_write(net_if, HFI_IP_RECV_SIZE,
(HF_PAYLOAD_RX_THRESHOLD << HF_PAYLOAD_RX_THRESH_SHIFT));
+ /* setup recv fifo out of order intr control to disable */
+ hf_mmio_regs_write(net_if, HFI_RFIFO_OUT_EVENT_REG,
+ HF_RFIFO_OUT_CNTL_REARM);
+
+ /* setup recv fifo out of order threshold */
+ hf_mmio_regs_write(net_if, HFI_RFIFO_OUT_TH_REG, HF_RFIFO_OUT_THRESH);
+
/* initialize SEND INTR STATUS */
hf_mmio_regs_write(net_if, HFI_SINTR_STATUS_REG, 0);
+
+ hf_mmio_regs_write(net_if, HFI_RFIFO_INJ_TH_REG,
+ (HF_RFIFO_CACHE_INJ_TH << HF_RFIFO_CACHE_INJ_TH_SHIFT));
+
+ /* enable and set receive intr */
+ hf_set_recv_intr(net_if);
}
static int hf_net_delayed_open(void *parm, u16 win, u16 ext)
@@ -402,6 +451,7 @@ static int hf_net_delayed_open(void *parm, u16 win, u16 ext)
net_if->state = HF_NET_OPEN;
spin_unlock(&(net_if->lock));
+ napi_enable(&net->napi);
netif_carrier_on(netdev);
netif_start_queue(netdev);
@@ -488,6 +538,7 @@ static int hf_net_close(struct net_device *netdev)
spin_lock(&(net_if->lock));
if (net_if->state == HF_NET_OPEN) {
+ napi_disable(&net->napi);
netif_stop_queue(netdev);
netif_carrier_off(netdev);
@@ -507,6 +558,245 @@ static int hf_net_close(struct net_device *netdev)
return 0;
}
+/* Invalidate the jobid field of each cache line before advancing head.
+ * The first cache line is protected by the valid bit, so we skip it. */
+static inline void hf_advance_rx_head(struct hf_if *net_if, u32 len)
+{
+ int i, h;
+ u32 *cache_p;
+
+ h = (net_if->rx_fifo.head + 1) & (net_if->rx_fifo.emax);
+
+ for (i = 1; i < len; i++) {
+ cache_p = (u32 *)((char *)(net_if->rx_fifo.addr) +
+ (h << HFI_CACHE_LINE_SHIFT));
+ if (*cache_p == HF_IP_JOBID)
+ *cache_p = 0;
+ h = (h + 1) & (net_if->rx_fifo.emax);
+ }
+
+ if (net_if->rx_fifo.head > h)
+ net_if->rx_pkt_valid ^= 0x1;
+
+ net_if->rx_fifo.head = h;
+}
+
+void hf_construct_hwhdr(struct hf_if *net_if,
+ struct sk_buff *skb,
+ struct base_hdr *b_hdr)
+{
+ struct ethhdr *hwhdr_p;
+
+ hwhdr_p = (struct ethhdr *)(skb->data);
+
+ /* MAC byte 1, bits6 = 1, locally admin MAC */
+ hwhdr_p->h_dest[0] = 0x2;
+ /* MAC byte 2, bits2-7 = cluster id */
+ hwhdr_p->h_dest[1] = 0x0;
+ *(u16 *)(&(hwhdr_p->h_dest[2])) = (u16)(b_hdr->dst_isr);
+ *(u16 *)(&(hwhdr_p->h_dest[4])) =
+ (u16)hf_get_mac(b_hdr->dst_win);
+
+ hwhdr_p->h_source[0] = 0x2;
+ hwhdr_p->h_source[1] = 0x0;
+ *(u16 *)(&(hwhdr_p->h_source[2])) = (u16)(b_hdr->src_isr);
+ *(u16 *)(&(hwhdr_p->h_source[4])) =
+ (u16)hf_get_mac(b_hdr->src_win);
+
+ hwhdr_p->h_proto = skb->protocol;
+}
+
+static inline int hf_check_hdr_version(struct hf_net *net,
+ struct hf_if_proto_hdr *hf_hdr)
+{
+ if (hf_hdr->version != HF_PROTO_HDR_VERSION) {
+ netdev_err(net->netdev,
+ "hf_check_hdr_version: hdr version 0x%x "
+ "does not match 0x%x\n",
+ hf_hdr->version, HF_PROTO_HDR_VERSION);
+ net->netdev->stats.rx_dropped++;
+ return -EINVAL;
+ }
+ return 0;
+}
+
+static void hf_recv_ip_with_payload(struct hf_net *net,
+ struct hfi_ip_with_payload_pkt *pkt,
+ u32 pkt_len)
+{
+ u32 len, resid;
+ struct hf_if *net_if = &(net->hfif);
+ struct net_device *netdev = net->netdev;
+ struct hf_if_proto_hdr *hf_hdr;
+ struct sk_buff *skb;
+ void *src, *dst;
+ u32 cache_ln_num = 0;
+ u16 proto;
+
+ /* retrieve the protocol header pointer */
+ hf_hdr = (struct hf_if_proto_hdr *)(pkt->payload);
+
+ if (hf_check_hdr_version(net, hf_hdr) != 0)
+ return;
+
+ switch (hf_hdr->msg_type) {
+ case HF_IF_ARP:
+ proto = htons(ETH_P_ARP);
+ break;
+
+ case HF_IF_FIFO:
+ proto = htons(ETH_P_IP);
+ break;
+
+ default:
+ netdev_err(net->netdev,
+ "hf_recv_ip_with_payload: unknown msg_type 0x%x\n",
+ hf_hdr->msg_type);
+ netdev->stats.rx_dropped++;
+ return;
+ }
+
+ len = hf_hdr->msg_len - HF_PROTO_LEN;
+
+ skb = netdev_alloc_skb_ip_align(net->netdev,
+ len + ETH_HLEN + HF_ALIGN_PAD);
+ if (!skb) {
+ netdev_err(net->netdev, "hf_recv_ip_with_payload: "
+ "netdev_alloc_skb_ip_align fail\n");
+ netdev->stats.rx_dropped++;
+ BUG();
+ return;
+ }
+
+ skb_reserve(skb, HF_ALIGN_PAD);
+ skb->protocol = proto;
+
+ skb_put(skb, len + ETH_HLEN);
+
+ /* construct ethhdr from base hdr */
+ hf_construct_hwhdr(net_if, skb, &(pkt->hfi_hdr.base_hdr));
+
+ skb_reset_mac_header(skb);
+
+ skb_pull(skb, ETH_HLEN);
+
+ src = (void *)(hf_hdr + 1);
+ dst = (void *)skb->data;
+
+ /* check if the payload wrapped the rx_fifo */
+ if ((net_if->rx_fifo.head + (pkt_len - 1)) > net_if->rx_fifo.emax) {
+ /* Wrapped */
+ cache_ln_num = net_if->rx_fifo.emax - net_if->rx_fifo.head + 1;
+ resid = cache_ln_num << HFI_CACHE_LINE_SHIFT;
+ resid -= (HF_IP_HDR_LEN + HF_PROTO_LEN);
+
+ /* For netboot, pkt_len maybe larger than len */
+ if (resid > len)
+ resid = len;
+
+ memcpy(dst, src, resid);
+
+ src = (void *)net_if->rx_fifo.addr;
+ dst = (void *)skb->data + resid;
+ len -= resid;
+ }
+
+ /* copy the rest of payload */
+ if (len > 0)
+ memcpy(dst, src, len);
+
+ skb->ip_summed = CHECKSUM_NONE;
+
+ netdev->stats.rx_packets++;
+ netdev->stats.rx_bytes += skb->len;
+
+ netif_receive_skb(skb);
+}
+
+static void hf_recv_ip_good(struct hf_net *net,
+ struct hfi_hdr *rx_curr,
+ u32 pkt_len)
+{
+ switch (rx_curr->type.header_type) {
+
+ case HFI_IP_WITH_PAYLOAD:
+ case HFI_IP_MULTICAST_WITH_PAYLOAD:
+ hf_recv_ip_with_payload(net,
+ (struct hfi_ip_with_payload_pkt *)rx_curr, pkt_len);
+ break;
+
+ default:
+ netdev_err(net->netdev, "hf_rx: receive unknown "
+ "headerType = 0x%x, pkt_len = 0x%x\n",
+ rx_curr->type.header_type, pkt_len);
+
+ /* unknown packet, drop it */
+ net->netdev->stats.rx_dropped++;
+ break;
+ }
+}
+
+static int hf_rx(struct hf_net *net, int budget)
+{
+ int num = 0;
+ struct hf_if *net_if = &(net->hfif);
+ u32 pkt_len, status;
+ struct hfi_hdr *rx_curr;
+ u32 job_id, pkt_valid;
+
+ rx_curr = (struct hfi_hdr *) (net_if->rx_fifo.addr +
+ (net_if->rx_fifo.head << HFI_CACHE_LINE_SHIFT));
+
+ while (budget != 0) {
+ job_id = rx_curr->id.job_id;
+ pkt_valid = rx_curr->base_hdr.pkt_valid;
+
+ isync();
+ if ((job_id != HF_IP_JOBID) ||
+ (pkt_valid != net_if->rx_pkt_valid))
+ break;
+
+ pkt_len = hfi_pktlen_to_cachelines(rx_curr->base_hdr.pkt_len);
+
+ status = rx_curr->base_hdr.status;
+ if (status == HFI_PKT_STATUS_GOOD) {
+ hf_recv_ip_good(net, rx_curr, pkt_len);
+ } else {
+ /* bad packet */
+ netdev_err(net->netdev, "hf_rx: receive bad "
+ "status = 0x%x, pkt_len = 0x%x\n",
+ status, pkt_len);
+
+ net->netdev->stats.rx_dropped++;
+ }
+
+ net->netdev->last_rx = jiffies;
+
+ hf_advance_rx_head(net_if, pkt_len);
+
+ /* Make sure the jobid is invalidated before posting to hw */
+ wmb();
+
+ net_if->rx_fslot_debt += pkt_len;
+ if (net_if->rx_fslot_debt >= HF_INC_FSLOT_WATERMARK) {
+ hf_mmio_regs_write(net_if, HFI_RFIFO_INC_FSLOT_REG,
+ net_if->rx_fslot_debt);
+ net_if->rx_fslot_debt = 0;
+ }
+
+ budget--;
+ num++;
+ rx_curr = net_if->rx_fifo.addr +
+ (net_if->rx_fifo.head << HFI_CACHE_LINE_SHIFT);
+
+ }
+
+ netdev_dbg(net->netdev, "hf_rx: exit, head = 0x%x, recv 0x%x pkts\n",
+ net_if->rx_fifo.head, num);
+
+ return num;
+}
+
static void hf_tx_recycle(struct hf_if *net_if)
{
u32 head, head_idx, slots_per_blk;
@@ -906,6 +1196,30 @@ static void hf_if_setup(struct net_device *netdev)
memcpy(netdev->broadcast, hfi_bcast_addr, ETH_ALEN);
}
+static int hf_poll(struct napi_struct *napi, int budget)
+{
+ int work_done;
+ struct net_device *netdev;
+ struct hf_net *net;
+ struct hf_if *net_if;
+
+ net = container_of(napi, struct hf_net, napi);
+ net_if = &(net->hfif);
+ netdev = net->netdev;
+
+ work_done = hf_rx(net, budget);
+
+ /* Always assume we have received all available packets */
+ /* and set recv intr for next packet */
+ if (work_done < budget) {
+ napi_complete(napi);
+ isync();
+ hf_set_recv_intr(net_if);
+ }
+
+ return work_done;
+}
+
static struct hf_net *hf_init_netdev(int idx, int ai)
{
struct net_device *netdev;
@@ -924,6 +1238,7 @@ static struct hf_net *hf_init_netdev(int idx, int ai)
}
net = netdev_priv(netdev);
+ netif_napi_add(netdev, &(net->napi), hf_poll, HF_NAPI_WEIGHT);
net->netdev = netdev;
memset(&(net->hfif), 0, sizeof(struct hf_if));
@@ -939,11 +1254,16 @@ static struct hf_net *hf_init_netdev(int idx, int ai)
netdev_err(netdev, "hf_init_netdev: "
"failed to register netdev=hfi%d:hf%d, "
"rc = 0x%x\n", ai, idx, rc);
- free_netdev(netdev);
- return ERR_PTR(-ENODEV);
+ goto err_out1;
}
return net;
+
+err_out1:
+ netif_napi_del(&(net->napi));
+ free_netdev(netdev);
+
+ return ERR_PTR(-ENODEV);
}
static void hf_del_netdev(struct hf_net *net)
@@ -952,6 +1272,8 @@ static void hf_del_netdev(struct hf_net *net)
unregister_netdev(netdev);
+ netif_napi_del(&(net->napi));
+
free_netdev(netdev);
}
diff --git a/include/linux/hfi/hfi_ip.h b/include/linux/hfi/hfi_ip.h
index 4e70c14..ec87300 100644
--- a/include/linux/hfi/hfi_ip.h
+++ b/include/linux/hfi/hfi_ip.h
@@ -38,6 +38,7 @@
#include <linux/init.h>
#include <linux/netdevice.h>
#include <linux/inetdevice.h>
+#include <linux/etherdevice.h>
#include <net/arp.h>
#include <linux/hfi/hfidd_internal.h>
@@ -56,6 +57,12 @@
#define HF_NAPI_WEIGHT 256
#define HF_MAX_NAME_LEN 64
+/* rfifo intr */
+#define HF_RFIFO_OUT_CNTL_REARM 0 /* 0 to disable interrupt */
+#define HF_IMM_RECV_INTR 0xf0000000 /* bit 32-35 on */
+#define HF_ENA_RECV_INTR 0xc0000000 /* bit 32-33 on */
+#define HF_RECV_INTR_MATCH_SHIFT 7 /* bit 37-56 */
+
/* sfifo intr: bit 39-55 is threshold */
/* bit 34 enable, bit 35 unmask */
#define HF_SFIFO_INTR_ENABLE (0x3 << (63 - 35))
@@ -74,11 +81,17 @@
#define HF_FV_BIT_MAX 31
#define HF_SEND_ONE 1
+#define HF_RFIFO_CACHE_INJ_TH 7ULL
+#define HF_RFIFO_CACHE_INJ_TH_SHIFT 61
+#define HF_RFIFO_OUT_THRESH 0
+
#define HF_PAYLOAD_MAX (2048 - HF_IP_HDR_LEN - HF_PROTO_LEN)
#define HF_NET_MTU HF_PAYLOAD_MAX
#define HF_PAYLOAD_RX_THRESHOLD 0x10ULL
#define HF_PAYLOAD_RX_THRESH_SHIFT 59
+#define HF_INC_FSLOT_WATERMARK (HF_RFIFO_SLOTS >> 3)
+
struct hfi_ip_extended_hdr { /* 16B */
unsigned int immediate_len:7;/* In bytes */
unsigned int num_desc:3; /* number of descriptors */
@@ -99,7 +112,9 @@ struct hfi_ip_with_payload_pkt {
#define HF_IP_HDR_LEN ((sizeof(struct hfi_hdr) + \
sizeof(struct hfi_ip_extended_hdr)))
+
#define HF_ALIGN_PAD 2
+
#define HF_PROTO_HDR_VERSION 0x1
/* HFI protocol message type */
#define HF_IF_ARP 0xA0
@@ -146,7 +161,10 @@ struct hf_if {
u32 sfifo_fv_polarity;
u32 sfifo_slots_per_blk;
u32 sfifo_packets;
+ u32 rx_pkt_valid; /* Polarity of recv
+ packet valid bit */
u32 msg_id;
+ u32 rx_fslot_debt;
void __iomem *doorbell; /* mapped mmio_regs */
struct hf_fifo tx_fifo;
struct hf_fifo rx_fifo;
@@ -159,6 +177,7 @@ struct hf_if {
/* Private structure for HF inetrface */
struct hf_net {
struct net_device *netdev;
+ struct napi_struct napi;
struct hf_if hfif;
};
@@ -172,7 +191,7 @@ struct hf_global_info {
extern struct hf_global_info hf_ginfo;
-#define HF_EVENT_NUM 1
+#define HF_EVENT_NUM 2
struct hf_events_cb {
enum hfi_event_type type;
@@ -182,6 +201,11 @@ struct hf_events_cb {
#define HF_MAC_HFI_SHIFT 12
#define HF_HDR_HFI_SHIFT 8
+static inline u32 hf_get_mac(u32 w)
+{
+ return ((w >> HF_HDR_HFI_SHIFT) << HF_MAC_HFI_SHIFT) | (w & 0xFF);
+}
+
static inline u32 hf_get_win(u16 id)
{
return ((id >> HF_MAC_HFI_SHIFT) << HF_HDR_HFI_SHIFT) | (id & 0xFF);
--
1.7.3.5
^ permalink raw reply related
* [PATCH v2 20/27] HFI: Close window hypervisor call
From: dykmanj @ 2011-04-18 3:21 UTC (permalink / raw)
To: netdev
Cc: Jim Dykman, Piyush Chaudhary, Fu-Chung Chang, William S. Cadden,
Wen C. Chen, Scot Sakolish, Jian Xiao, Carol L. Soto,
Sarah J. Sheppard
In-Reply-To: <1303096919-7367-1-git-send-email-dykmanj@linux.vnet.ibm.com>
From: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Piyush Chaudhary <piyushc@linux.vnet.ibm.com>
Signed-off-by: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
Signed-off-by: William S. Cadden <wscadden@linux.vnet.ibm.com>
Signed-off-by: Wen C. Chen <winstonc@linux.vnet.ibm.com>
Signed-off-by: Scot Sakolish <sakolish@linux.vnet.ibm.com>
Signed-off-by: Jian Xiao <jian@linux.vnet.ibm.com>
Signed-off-by: Carol L. Soto <clsoto@linux.vnet.ibm.com>
Signed-off-by: Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
---
drivers/net/hfi/core/hfidd_hcalls.c | 22 ++++++++++++++
drivers/net/hfi/core/hfidd_proto.h | 1 +
drivers/net/hfi/core/hfidd_window.c | 53 +++++++++++++++++++++++++++++++++--
3 files changed, 73 insertions(+), 3 deletions(-)
diff --git a/drivers/net/hfi/core/hfidd_hcalls.c b/drivers/net/hfi/core/hfidd_hcalls.c
index 1915336..4bc6525 100644
--- a/drivers/net/hfi/core/hfidd_hcalls.c
+++ b/drivers/net/hfi/core/hfidd_hcalls.c
@@ -153,6 +153,17 @@ static inline long long h_hfi_open_window(int token,
return rc;
}
+static inline long long h_hfi_close_window(int token,
+ u64 HFI_chip_ID,
+ u64 win_num,
+ u64 flag)
+{
+ return plpar_hcall_norets(token,
+ HFI_chip_ID,
+ win_num,
+ flag);
+}
+
long long hfi_start_nmmu(u64 chip_id, void *nmmu_info)
{
return h_nmmu_start(H_NMMU_START, chip_id, nmmu_info);
@@ -249,6 +260,17 @@ long long hfi_modify_mr(u64 chip_id, u64 request, u64 mr_handle,
return hvrc;
}
+long long hfi_close_window(u64 unit_id, u64 win_id, u64 flag)
+{
+ long long hvrc;
+
+ hvrc = h_hfi_close_window(H_HFI_CLOSE_WINDOW,
+ unit_id,
+ win_id,
+ flag);
+ return hvrc;
+}
+
long long hfi_free_mr(u64 chip_id, u64 res, u64 mr_handle, u64 sub_region_id)
{
long long hvrc;
diff --git a/drivers/net/hfi/core/hfidd_proto.h b/drivers/net/hfi/core/hfidd_proto.h
index e065d56..f531dcd 100644
--- a/drivers/net/hfi/core/hfidd_proto.h
+++ b/drivers/net/hfi/core/hfidd_proto.h
@@ -94,6 +94,7 @@ long long hfi_modify_mr(u64 chip_id, u64 request, u64 mr_handle,
u64 e_addr,
u64 l_addr,
u64 num_pg_sz);
+long long hfi_close_window(u64 unit_id, u64 win_id, u64 flag);
long long hfi_free_mr(u64 chip_id, u64 res, u64 mr_handle,
u64 sub_region_id);
long long hfi_hquery_interface(u64 unit_id, u64 subtype, u64 query_p,
diff --git a/drivers/net/hfi/core/hfidd_window.c b/drivers/net/hfi/core/hfidd_window.c
index 3cfe5c3..fd692eb 100644
--- a/drivers/net/hfi/core/hfidd_window.c
+++ b/drivers/net/hfi/core/hfidd_window.c
@@ -459,6 +459,43 @@ static int hfi_hcall_to_open_window(struct hfidd_acs *p_acs,
return 0;
}
+/* Call to CLOSE WINDOW hcall */
+static int hfi_hcall_to_close_window(struct hfidd_acs *p_acs,
+ struct hfidd_window *win_p)
+{
+ int rc = 0;
+ long long hvrc = 0;
+ u64 start_time = get_jiffies_64();
+
+ hvrc = hfi_close_window(p_acs->dds.hfi_id,
+ win_p->index,
+ H_CLOSE);
+
+ /*
+ * Need to call CLOSE WINDOW with flag H_CHECK_CLOSED
+ * to check when the window is completely closed
+ */
+ while (hvrc == H_BUSY) {
+ hvrc = hfi_close_window(p_acs->dds.hfi_id,
+ win_p->index,
+ H_CHECK_CLOSED);
+ if (hvrc != H_BUSY)
+ break;
+ if (hfidd_age_hcall(start_time))
+ break;
+ }
+
+ if (hvrc != H_SUCCESS) {
+ win_p->state = WIN_FAIL_CLOSE;
+ rc = -EIO;
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfi_hcall_to_close_window: CLOSE WINDOW failed, "
+ "hvrc=0x%llx\n", hvrc);
+ }
+
+ return rc;
+}
+
/*
* Map the Effective Address pages for Memory Regions.
* If more than one page, need to setup a page containing
@@ -1005,7 +1042,7 @@ int hfidd_open_window_func(struct hfidd_acs *p_acs, unsigned int is_userspace,
dev_printk(KERN_ERR, p_acs->hfidd_dev,
"hfidd_open_window_func: hfi_map_mmio_regs "
"failed, rc = 0x%x\n", rc);
- goto hfidd_open_window_func_err4;
+ goto hfidd_open_window_func_err5;
}
/* tell user the local ISR id */
@@ -1019,7 +1056,7 @@ int hfidd_open_window_func(struct hfidd_acs *p_acs, unsigned int is_userspace,
dev_printk(KERN_ERR, p_acs->hfidd_dev,
"hfidd_open_window_func: hfi_copy_to_user "
"failed, rc = 0x%x\n", rc);
- goto hfidd_open_window_func_err5;
+ goto hfidd_open_window_func_err6;
}
spin_lock(&(win_p->win_lock));
@@ -1031,9 +1068,11 @@ int hfidd_open_window_func(struct hfidd_acs *p_acs, unsigned int is_userspace,
kfree(local_p);
return rc;
-hfidd_open_window_func_err5:
+hfidd_open_window_func_err6:
if (is_userspace)
hfidd_unmap(local_p->mmio_regs.use.kptr, PAGE_SIZE_64K);
+hfidd_open_window_func_err5:
+ hfi_hcall_to_close_window(p_acs, win_p);
hfidd_open_window_func_err4:
hfi_destroy_window_parm(p_acs, is_userspace, win_p, local_p);
hfidd_open_window_func_err3:
@@ -1103,6 +1142,14 @@ int hfidd_close_window_internal(struct hfidd_acs *p_acs,
goto hfidd_close_window_internal_err0;
}
+ rc = hfi_hcall_to_close_window(p_acs, win_p);
+ if (rc) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_close_window_internal: hfi_hcall_to_close_window "
+ "failed, rc = 0x%x\n", rc);
+ goto hfidd_close_window_internal_err0;
+ }
+
hfi_destroy_window_info(p_acs, win_p);
/* Call hcall to unregister MR in the MMU */
--
1.7.3.5
^ permalink raw reply related
* [PATCH v2 22/27] HFI: Add event notifications
From: dykmanj @ 2011-04-18 3:21 UTC (permalink / raw)
To: netdev
Cc: Jim Dykman, Piyush Chaudhary, Fu-Chung Chang, William S. Cadden,
Wen C. Chen, Scot Sakolish, Jian Xiao, Carol L. Soto,
Sarah J. Sheppard
In-Reply-To: <1303096919-7367-1-git-send-email-dykmanj@linux.vnet.ibm.com>
From: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Interrupts and some error notifications get passed to window users through
events. User-space applications can register for a signal to be delivered
or can spawn a thread to call into the HFI DD and wait.
Kernel windows can register callbacks.
Signed-off-by: Piyush Chaudhary <piyushc@linux.vnet.ibm.com>
Signed-off-by: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
Signed-off-by: William S. Cadden <wscadden@linux.vnet.ibm.com>
Signed-off-by: Wen C. Chen <winstonc@linux.vnet.ibm.com>
Signed-off-by: Scot Sakolish <sakolish@linux.vnet.ibm.com>
Signed-off-by: Jian Xiao <jian@linux.vnet.ibm.com>
Signed-off-by: Carol L. Soto <clsoto@linux.vnet.ibm.com>
Signed-off-by: Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
---
drivers/net/hfi/core/Makefile | 1 +
drivers/net/hfi/core/hfidd_adpt.c | 5 +
drivers/net/hfi/core/hfidd_events.c | 1098 +++++++++++++++++++++++++++++++++++
drivers/net/hfi/core/hfidd_init.c | 35 ++
drivers/net/hfi/core/hfidd_intr.c | 40 ++-
drivers/net/hfi/core/hfidd_proto.h | 16 +-
drivers/net/hfi/core/hfidd_window.c | 24 +
include/linux/hfi/hfidd_client.h | 64 ++
include/linux/hfi/hfidd_internal.h | 69 +++
include/linux/hfi/hfidd_requests.h | 3 +
10 files changed, 1353 insertions(+), 2 deletions(-)
create mode 100644 drivers/net/hfi/core/hfidd_events.c
diff --git a/drivers/net/hfi/core/Makefile b/drivers/net/hfi/core/Makefile
index d2ed86f..da71824 100644
--- a/drivers/net/hfi/core/Makefile
+++ b/drivers/net/hfi/core/Makefile
@@ -3,6 +3,7 @@
#
hfi_core-objs:= hfidd_adpt.o \
hfidd_window.o \
+ hfidd_events.o \
hfidd_init.o \
hfidd_xlat.o \
hfidd_map.o \
diff --git a/drivers/net/hfi/core/hfidd_adpt.c b/drivers/net/hfi/core/hfidd_adpt.c
index b99303b..1f4d4d7 100644
--- a/drivers/net/hfi/core/hfidd_adpt.c
+++ b/drivers/net/hfi/core/hfidd_adpt.c
@@ -116,6 +116,7 @@ int hfidd_alloc_windows(struct hfidd_acs *p_acs)
/* Initialize window fields */
spin_lock_init(&(p_acs->win[i]->win_lock));
+ spin_lock_init(&(p_acs->win[i]->event_lock));
p_acs->win[i]->ai = p_acs->index;
p_acs->win[i]->index = p_acs->dds.window_start + i;
@@ -136,6 +137,8 @@ void hfidd_free_windows(struct hfidd_acs *p_acs)
int i;
for (i = 0; i < p_acs->dds.window_num; i++) {
+ if (p_acs->win[i])
+ hfidd_events_clean(p_acs, p_acs->win[i]);
kfree(p_acs->win[i]);
p_acs->win[i] = NULL;
}
@@ -208,6 +211,8 @@ int hfidd_query_interface(struct hfidd_acs *p_acs, unsigned int subtype,
if (p_acs->state != HFI_AVAIL) {
p_acs->isr = query_p->local_node_id;
p_acs->state = HFI_AVAIL;
+ /* Notify user that adapter is ready */
+ hfidd_notify_hfi_ready(p_acs);
}
} else {
p_acs->state = HFI_UNAVAIL;
diff --git a/drivers/net/hfi/core/hfidd_events.c b/drivers/net/hfi/core/hfidd_events.c
new file mode 100644
index 0000000..ff92306
--- /dev/null
+++ b/drivers/net/hfi/core/hfidd_events.c
@@ -0,0 +1,1098 @@
+/* hfidd_events.c
+ *
+ * HFI device driver for IBM System p
+ *
+ * Authors:
+ * Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
+ * William S. Cadden <wscadden@linux.vnet.ibm.com>
+ * Wen C. Chen <winstonc@linux.vnet.ibm.com>
+ * Scot Sakolish <sakolish@linux.vnet.ibm.com>
+ * Jian Xiao <jian@linux.vnet.ibm.com>
+ * Carol L. Soto <clsoto@linux.vnet.ibm.com>
+ * Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
+ *
+ * (C) Copyright IBM Corp. 2010
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include <linux/hfi/hfidd_internal.h>
+#include "hfidd_proto.h"
+
+static void rem_events(struct hfidd_acs *p_acs, struct hfidd_window *win,
+ struct hfidd_tid_info *tid_info, unsigned int events,
+ struct hfidd_win_event **event_list);
+static int hfidd_hfi_ready_registration(struct hfidd_acs *p_acs,
+ struct hfi_reg_events *reg);
+static void hfidd_hfi_ready_unregistration(struct hfidd_acs *p_acs,
+ struct hfi_reg_events *reg);
+
+static unsigned int event_mask[HFIDD_NUM_EVENT_TYPES] = {
+ HFIDD_SEND_EVENT,
+ HFIDD_RECV_EVENT,
+ HFIDD_WIN_ERROR_EVENT,
+ HFIDD_HFI_ERROR_EVENT,
+ HFIDD_TERMINATE_EVENT,
+ HFIDD_RELEASE_WINDOW_EVENT,
+ HFIDD_CAU_ERROR_EVENT,
+ HFIDD_ICS_ERROR_EVENT,
+ HFIDD_HFI_READY_REG_EVENT,
+ HFIDD_ROUTE_CHANGE_EVENT,
+ HFIDD_IP_TRC_LVL_EVENT,
+ HFIDD_POOL_SIZE_EVENT};
+
+
+static void hfidd_tid_info_init(struct hfidd_tid_info *tid_info)
+{
+ memset(tid_info, 0, sizeof(*tid_info));
+ sema_init(&(tid_info->tid_sem), 1);
+ INIT_LIST_HEAD(&(tid_info->event_list));
+ init_waitqueue_head(&(tid_info->event_wait));
+ tid_info->th = current;
+}
+
+static void hfidd_tid_info_end(struct hfidd_tid_info *tid_info,
+ struct hfidd_q_event **q_event_list)
+{
+ struct list_head *pos;
+ struct list_head *q;
+ struct hfidd_q_event *ev;
+
+ /* Clean up any remaining events. */
+ list_for_each_safe(pos, q, &(tid_info->event_list)) {
+ ev = list_entry(pos, struct hfidd_q_event, list);
+ list_del(pos);
+ ev->next = *q_event_list;
+ *q_event_list = ev;
+ }
+}
+
+static inline void hfidd_update_eb(struct hfidd_tid_info *tid_info,
+ struct hfi_reg_events *reg_events)
+{
+ tid_info->eb_xd = current->group_leader;
+ tid_info->eb = (struct hfi_event_buffer *)reg_events->info.eb.use.allu;
+}
+
+/* Post an event. The win->event_lock must be held before calling. */
+static int hfidd_post_event(struct hfidd_acs *p_acs,
+ struct hfidd_tid_info *tid_info, enum hfi_event_type type,
+ unsigned int event, struct hfidd_q_event **q_event_list)
+{
+ int rc = 0;
+ struct hfidd_q_event *ev;
+
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "hfidd_post_event: event=0x%x tid=0x%llx\n",
+ event, tid_info->tid);
+
+ if (tid_info->type == WAIT_FOR_EVENTS) {
+ /* Allocate and fill in the structure for the event. */
+ if (*q_event_list == NULL) {
+ rc = -EFAULT;
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_post_event: internal error - "
+ "%d\n", rc);
+ } else {
+ ev = *q_event_list;
+ *q_event_list = (*q_event_list)->next;
+ ev->event = event;
+
+ /*
+ * Add the event to the event list and wake up any
+ * waiting thread.
+ */
+ list_add(&(ev->list), &(tid_info->event_list));
+ wake_up_interruptible(&(tid_info->event_wait));
+ }
+ }
+
+ return rc;
+}
+
+/*
+ * Wakeup waiting task if necessary. The win->event_lock must be held before
+ * calling.
+ */
+static int hfidd_events_wakeup(struct hfidd_acs *p_acs,
+ struct hfidd_tid_info *tid_info,
+ struct hfidd_q_event **q_event_list)
+{
+ int rc = 0;
+ struct list_head *pos;
+ struct list_head *q;
+ struct hfidd_q_event *ev;
+
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "hfidd_events_wakeup: tid=0x%llx\n", tid_info->tid);
+ /*
+ * A well behaved thread will not be waiting for any events when
+ * wakeup is called. This code is to handle misbehaving threads.
+ */
+
+ /*
+ * Add an event that will cause any misbehaving waiting thread to
+ * wake up. Once it wakes up, it will see that we are cleaning up
+ * (because win->open_close_count has changed) and will end.
+ */
+ if (*q_event_list == NULL) {
+ rc = -EFAULT;
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_events_wakeup: internal error - "
+ "%d\n", rc);
+ goto hfidd_events_wakeup_error1;
+ }
+
+ ev = *q_event_list;
+ *q_event_list = (*q_event_list)->next;
+ ev->event = HFIDD_TERMINATE;
+ list_add(&(ev->list), &(tid_info->event_list));
+ wake_up_interruptible(&(tid_info->event_wait));
+
+ /* By getting this lock, we make sure that we don't delete tid_info */
+ /* until the thread is done using it. */
+ down(&(tid_info->tid_sem));
+
+ list_for_each_safe(pos, q, &(tid_info->event_list)) {
+ ev = list_entry(pos, struct hfidd_q_event, list);
+ list_del(pos);
+ ev->next = *q_event_list;
+ *q_event_list = ev;
+ }
+
+ up(&(tid_info->tid_sem));
+
+
+hfidd_events_wakeup_error1:
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "hfidd_events_wakeup: rc=%d\n", rc);
+ return rc;
+}
+
+/*
+ * Preallocate a group of q events. We must preallocate because we are
+ * not allowed to use kzalloc once we have the event_lock.
+ */
+static struct hfidd_q_event *hfidd_prealloc_q_events(struct hfidd_acs *p_acs,
+ struct hfidd_window *win, int num_events)
+{
+ int i;
+ struct hfidd_q_event *q_event_list = NULL;
+ struct hfidd_q_event *q_event;
+
+ for (i = 0; i < num_events; i++) {
+ q_event = kzalloc(sizeof(*q_event), GFP_KERNEL);
+ if (q_event == NULL) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_prealloc_q_events: kzalloc failed, "
+ "num_events = %d\n", num_events);
+
+ while (q_event_list != NULL) {
+ q_event = q_event_list->next;
+ kfree(q_event_list);
+ q_event_list = q_event;
+ }
+ return NULL;
+ }
+ q_event->next = q_event_list;
+ q_event_list = q_event;
+ }
+
+ return q_event_list;
+}
+
+/* Return any queue events that haven't been used. */
+static void hfidd_return_q_events(struct hfidd_acs *p_acs,
+ struct hfidd_q_event **q_event_list)
+{
+ struct hfidd_q_event *q_event;
+
+ while (*q_event_list != NULL) {
+ q_event = (*q_event_list)->next;
+ kfree(*q_event_list);
+ *q_event_list = q_event;
+ }
+}
+/*
+ * Preallocate a tid_info structure. We must preallocate because we are
+ * not allowed to use kzalloc once we have the event_lock.
+ */
+static struct hfidd_tid_info *prealloc_tid_list(struct hfidd_acs *p_acs)
+{
+ struct hfidd_tid_info *tid_list;
+
+ tid_list = kzalloc(sizeof(*tid_list), GFP_KERNEL);
+ if (tid_list == NULL) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "prealloc_tid_list: kzalloc tid info failed\n");
+ } else {
+ hfidd_tid_info_init(tid_list);
+ tid_list->next = NULL;
+ }
+ return tid_list;
+}
+
+/* Return a list of hfidd_tid_info structures. */
+static void return_tid_list(struct hfidd_acs *p_acs,
+ struct hfidd_tid_info **tid_list,
+ struct hfidd_q_event **q_event_list)
+{
+ struct hfidd_tid_info *tid_info;
+
+ while (*tid_list != NULL) {
+ tid_info = *tid_list;
+ *tid_list = tid_info->next;
+ hfidd_tid_info_end(tid_info, q_event_list);
+ kfree(tid_info);
+ }
+}
+
+/*
+ * Preallocate a list of hfidd_win_event structures. We must preallocate
+ * because we are not allowed to use kzalloc once we have the event_lock.
+ */
+static struct hfidd_win_event *prealloc_event_list(struct hfidd_acs *p_acs,
+ unsigned int events)
+{
+ int i;
+ unsigned int test_bit = HFIDD_LOWEST_EVENT;
+ struct hfidd_win_event *win_event;
+ struct hfidd_win_event *event_list = NULL;
+
+ for (i = 0; i < HFIDD_NUM_EVENT_TYPES; i++) {
+ if (events & test_bit) {
+ win_event = kzalloc(sizeof(*win_event), GFP_KERNEL);
+ if (win_event == NULL) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "prealloc_event_list: kzalloc failed\n");
+
+ while (event_list != NULL) {
+ win_event = event_list;
+ event_list = event_list->next;
+ kfree(win_event);
+ }
+ return NULL;
+ }
+ win_event->next = event_list;
+ event_list = win_event;
+ }
+ test_bit <<= 1;
+ }
+ return event_list;
+}
+
+/* Return a list of hfidd_win_event structures. */
+static void return_event_list(struct hfidd_acs *p_acs,
+ struct hfidd_win_event **event_list)
+{
+ struct hfidd_win_event *win_event;
+
+ while (*event_list != NULL) {
+ win_event = *event_list;
+ *event_list = (*event_list)->next;
+ kfree(win_event);
+ }
+}
+
+/*
+ * Add a group of events to the event handling structures. The caller must
+ * hold win->event_lock.
+ */
+static int add_events(struct hfidd_acs *p_acs, struct hfidd_window *win,
+ struct hfidd_tid_info *tid_info, unsigned int events,
+ struct hfidd_win_event **event_list)
+{
+ int rc = 0;
+ int i;
+ unsigned int test_bit = HFIDD_LOWEST_EVENT;
+ struct hfidd_win_event *win_event;
+
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "add_events: enter win=0x%x events=0x%x\n",
+ win->index, events);
+
+ /* Add individual pointers from the window to the tid_info. */
+ for (i = 0; i < HFIDD_NUM_EVENT_TYPES; i++) {
+ if (events & test_bit) {
+ /* Add a pointer from the window to the events. */
+ if (*event_list == NULL) {
+ rc = -EFAULT;
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "add_events: internal error - "
+ "%d\n", rc);
+
+ goto add_events_err1;
+ }
+ win_event = *event_list;
+ *event_list = (*event_list)->next;
+ win_event->tid_info = tid_info;
+ win_event->next = win->events[i];
+ win->events[i] = win_event;
+ atomic_inc(&(win->num_events[i]));
+ }
+ test_bit <<= 1;
+ }
+ return rc;
+
+add_events_err1:
+ rem_events(p_acs, win, tid_info, events, event_list);
+ return rc;
+}
+
+/*
+ * Remove a group of events from the event handling structures. The caller
+ * must hold win->event_lock.
+ */
+static void rem_events(struct hfidd_acs *p_acs, struct hfidd_window *win,
+ struct hfidd_tid_info *tid_info, unsigned int events,
+ struct hfidd_win_event **event_list)
+{
+ int i;
+ unsigned int test_bit = HFIDD_LOWEST_EVENT;
+ struct hfidd_win_event *prev_win_event;
+ struct hfidd_win_event *win_event;
+ unsigned int temp_events = events;
+
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "rem_events: enter win=0x%x events=0x%x\n",
+ win->index, events);
+
+ for (i = 0; i < HFIDD_NUM_EVENT_TYPES; i++) {
+ if (temp_events & test_bit) {
+ /* Remove pointer from the window or p_acs to events. */
+ prev_win_event = NULL;
+ for (win_event = win->events[i]; win_event != NULL;
+ win_event = win_event->next) {
+ /* Search for this tid in list. */
+ if (win_event->tid_info == tid_info)
+ break;
+ else
+ prev_win_event = win_event;
+ }
+ if (win_event != NULL) {
+ /* Found tid. Remove it. */
+ if (prev_win_event == NULL)
+ win->events[i] = win_event->next;
+ else
+ prev_win_event->next = win_event->next;
+ win_event->next = *event_list;
+ *event_list = win_event;
+ atomic_dec(&(win->num_events[i]));
+ }
+ }
+ test_bit <<= 1;
+ }
+}
+
+/*
+ * Find a tid_info structure for a given tid and window. The caller must
+ * hold win->event_lock.
+ */
+static struct hfidd_tid_info *get_tid_info(struct hfidd_acs *p_acs,
+ struct hfidd_window *win, unsigned long long tid,
+ enum hfi_event_hndlr_type type,
+ struct hfidd_tid_info **prev_tid_info,
+ struct hfidd_tid_info **tid_list)
+{
+ struct hfidd_tid_info *tid_info;
+
+ *prev_tid_info = NULL;
+
+ /* See if it exists already. */
+ for (tid_info = win->tid_list; tid_info != NULL;
+ tid_info = tid_info->next) {
+ if (tid_info->tid == tid)
+ break;
+ *prev_tid_info = tid_info;
+ }
+
+ /* Allocate new structure if necessary. */
+ if (tid_info == NULL) {
+ *prev_tid_info = NULL;
+ if (*tid_list == NULL) {
+ tid_info = NULL;
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "get_tid_info: internal error\n");
+ } else {
+ tid_info = *tid_list; /* Set to NULL so caller knows the
+ preallocated tid_info
+ structure was used. */
+ *tid_list = (*tid_list)->next;
+ tid_info->tid = tid;
+ tid_info->type = type;
+ atomic_inc(&win->num_tids);
+ tid_info->next = win->tid_list;
+ win->tid_list = tid_info;
+ }
+ }
+
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "get_tid_info: exit reg_events=0x%x tid_info=%p\n",
+ tid_info->registered_events,
+ (void *) tid_info);
+
+ return tid_info;
+}
+
+/*
+ * Remove a tid_info structure for a given tid and window. The caller must
+ * hold win->event_lock.
+ */
+static void rem_tid_info(struct hfidd_acs *p_acs, struct hfidd_window *win,
+ struct hfidd_tid_info *prev_tid_info,
+ struct hfidd_tid_info *tid_info,
+ struct hfidd_tid_info **tid_list)
+{
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "rem_tid_info: remove tid_info for tid 0x%llx\n",
+ tid_info->tid);
+
+ if (prev_tid_info == NULL)
+ win->tid_list = tid_info->next;
+ else
+ prev_tid_info->next = tid_info->next;
+ if (atomic_read(&win->num_tids) > 0)
+ atomic_dec(&win->num_tids);
+ tid_info->next = *tid_list;
+ *tid_list = tid_info; /* Set up to free after releasing lock */
+}
+
+
+/* Register events. */
+int hfidd_events_register(struct hfidd_acs *p_acs, struct hfi_reg_events *arg)
+{
+ int rc = 0;
+ int got_lock = 0;
+ struct hfi_reg_events reg_events;
+ unsigned long long tid;
+ struct hfidd_tid_info *prev_tid_info;
+ struct hfidd_tid_info *tid_info = NULL;
+ struct hfidd_tid_info *tid_list = NULL;
+ unsigned int new_events;
+ struct hfidd_window *win = NULL;
+ struct hfidd_win_event *event_list = NULL;
+ unsigned long flags = 0;
+ struct hfidd_q_event *q_event_list = NULL;
+
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "hfidd_events_register: enter p_acs=0x%p\n", (void *)p_acs);
+
+ /* Copy in client info from user */
+ rc = copy_from_user(®_events, arg, sizeof(reg_events));
+ if (rc) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_events_register: copy_from_user failed, "
+ "rc=0x%x\n", rc);
+ return rc;
+ }
+
+ /* Verify inputs */
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "hfidd_events_register: enter type=0x%x win=0x%x "
+ "events=0x%x\n", reg_events.type, reg_events.window,
+ reg_events.info.events);
+
+ if ((reg_events.type != WAIT_FOR_EVENTS) &&
+ (reg_events.type != SIGNAL_EVENTS)) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_events_register: invalid type - "
+ "0x%x\n", reg_events.type);
+ return -EINVAL;
+ }
+ if ((reg_events.window < min_hfi_windows(p_acs)) ||
+ (reg_events.window >= max_hfi_windows(p_acs))) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_events_register: invalid win - "
+ "0x%x\n", reg_events.window);
+ return -EINVAL;
+ }
+ if ((reg_events.type == WAIT_FOR_EVENTS) &&
+ (reg_events.info.events & ~HFIDD_ALL_EVENTS)) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_events_register: invalid events - "
+ "0x%x\n", reg_events.info.events & ~HFIDD_ALL_EVENTS);
+ return -EINVAL;
+ }
+ if ((reg_events.type == SIGNAL_EVENTS) &&
+ (reg_events.info.eb.use.kptr == NULL)) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_events_register: invalid signal buffer\n");
+ return -EINVAL;
+ }
+
+ win = hfi_window(p_acs, reg_events.window);
+ /*
+ * Preallocate data structures. We must do this before the
+ * lock or it will cause errors.
+ */
+ tid_list = prealloc_tid_list(p_acs);
+ if (tid_list == NULL)
+ return -ENOMEM;
+ if (reg_events.type == WAIT_FOR_EVENTS)
+ event_list = prealloc_event_list(p_acs, reg_events.info.events);
+ else
+ event_list = prealloc_event_list(p_acs, HFIDD_ALL_EVENTS);
+ if (event_list == NULL) {
+ rc = -ENOMEM;
+ goto events_reg_err1;
+ }
+
+ spin_lock_irqsave(&(win->event_lock), flags);
+ got_lock = 1;
+ if (win->state == WIN_AVAILABLE) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_events_register: inv state wi=0x%x st=0x%x\n",
+ win->index, win->state);
+ rc = -EINVAL;
+ goto events_reg_err1;
+ }
+
+ /* Get the tid_info structure for this tid. */
+ tid = (current->pid);
+
+ tid_info = get_tid_info(p_acs, win, tid, reg_events.type,
+ &prev_tid_info, &tid_list);
+ if (tid_info == NULL)
+ goto events_reg_err1;
+ if (tid_info->type != reg_events.type) {
+ /* The user can't change types after first registration */
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_events_register: inv typ chg old=0x%x new=0x%x\n",
+ tid_info->type, reg_events.type);
+ rc = -EINVAL;
+ goto events_reg_err2;
+ }
+
+ /* Add new event entries. */
+ if (reg_events.type == WAIT_FOR_EVENTS) {
+ new_events = ~tid_info->registered_events &
+ reg_events.info.events;
+ } else {
+ /*
+ * If signal version is registered more than once, this will
+ * end up with no events. Otherwise, all events
+ */
+ new_events = (~tid_info->registered_events) &
+ HFIDD_ALL_EVENTS;
+ hfidd_update_eb(tid_info, ®_events);
+ }
+ rc = add_events(p_acs, win, tid_info, new_events, &event_list);
+ if (rc) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_events_register: failed to add events, "
+ "rc=%d\n", rc);
+ goto events_reg_err2;
+ }
+ tid_info->registered_events |= new_events;
+
+events_reg_err2:
+ /* Remove tid info if necessary */
+ if (!(tid_info->registered_events))
+ rem_tid_info(p_acs, win, prev_tid_info, tid_info, &tid_list);
+
+events_reg_err1:
+
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "hfidd_events_register: rc=%d events=0x%x\n",
+ rc, (tid_info == NULL) ? 0 : tid_info->registered_events);
+
+ if (got_lock)
+ spin_unlock_irqrestore(&(win->event_lock), flags);
+ return_tid_list(p_acs, &tid_list, &q_event_list);
+ hfidd_return_q_events(p_acs, &q_event_list);
+ return_event_list(p_acs, &event_list);
+ return rc;
+}
+
+int hfidd_events_unregister(struct hfidd_acs *p_acs, struct hfi_reg_events *arg)
+{
+ int rc = 0;
+ int got_lock = 0;
+ struct hfi_reg_events unreg_events;
+ unsigned long long tid;
+ struct hfidd_tid_info *prev_tid_info;
+ struct hfidd_tid_info *tid_info = NULL;
+ struct hfidd_tid_info *tid_list = NULL;
+ struct hfidd_window *win = NULL;
+ struct hfidd_win_event *event_list = NULL;
+ unsigned long flags = 0;
+ struct hfidd_q_event *q_event_list = NULL;
+ unsigned int events_to_rem;
+
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "hfidd_events_unregister: enter p_acs=0x%p\n", (void *)p_acs);
+
+ /* Copy in client info from user */
+ rc = copy_from_user(&unreg_events, arg, sizeof(unreg_events));
+ if (rc) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_events_unregister: COPYIN err rc=0x%x\n", rc);
+ return rc;
+ }
+
+ /* Validate input */
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "hfidd_events_unregister: enter win=0x%x events=0x%x\n",
+ unreg_events.window, unreg_events.info.events);
+
+ if ((unreg_events.type != WAIT_FOR_EVENTS) &&
+ (unreg_events.type != SIGNAL_EVENTS)) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_events_unregister: invalid type - "
+ "0x%x\n", unreg_events.type);
+ return -EINVAL;
+ }
+
+ if ((unreg_events.window < min_hfi_windows(p_acs)) ||
+ (unreg_events.window >= max_hfi_windows(p_acs))) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_events_unregister: invalid win - "
+ "0x%x\n", unreg_events.window);
+ return -EINVAL;
+ }
+
+ if ((unreg_events.type == WAIT_FOR_EVENTS) &&
+ (unreg_events.info.events & ~HFIDD_ALL_EVENTS)) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_events_unregister: invalid events - "
+ "0x%x\n", unreg_events.info.events & ~HFIDD_ALL_EVENTS);
+ return -EINVAL;
+ }
+ win = hfi_window(p_acs, unreg_events.window);
+
+ /*
+ * Preallocate data structures. We must do this before the
+ * lock or it will cause errors.
+ */
+ tid_list = prealloc_tid_list(p_acs);
+ if (tid_list == NULL)
+ return -ENOMEM;
+ spin_lock_irqsave(&(win->event_lock), flags);
+ got_lock = 1;
+
+ /* Get the tid_info structure for this tid. */
+ tid = (current->pid);
+
+ tid_info = get_tid_info(p_acs, win, tid, unreg_events.type,
+ &prev_tid_info, &tid_list);
+ if (tid_info == NULL)
+ goto events_unreg_err1;
+ if (tid_info->type != unreg_events.type) {
+ /* The user can't change types after first registration */
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_events_unregister: inv typ chg old=0x%x new=0x%x\n",
+ tid_info->type, unreg_events.type);
+ rc = -EINVAL;
+ goto events_unreg_err2;
+ }
+
+ /* Remove entries. */
+ if (unreg_events.type == WAIT_FOR_EVENTS)
+ events_to_rem = unreg_events.info.events;
+ else
+ events_to_rem = HFIDD_ALL_EVENTS;
+ rem_events(p_acs, win, tid_info, events_to_rem, &event_list);
+ tid_info->registered_events &= ~events_to_rem;
+
+events_unreg_err2:
+ /* Remove tid_info if necessary. */
+ if (!(tid_info->registered_events))
+ rem_tid_info(p_acs, win, prev_tid_info, tid_info, &tid_list);
+
+events_unreg_err1:
+
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "hfidd_events_unregister: rc=%d events=0x%x\n",
+ rc, (tid_info == NULL) ? 0 : tid_info->registered_events);
+
+ if (got_lock)
+ spin_unlock_irqrestore(&(win->event_lock), flags);
+ return_tid_list(p_acs, &tid_list, &q_event_list);
+ hfidd_return_q_events(p_acs, &q_event_list);
+ return_event_list(p_acs, &event_list);
+ return rc;
+}
+
+/* Report that an event has occurred. */
+int hfidd_report_event(struct hfidd_acs *p_acs, struct hfidd_window *win,
+ enum hfi_event_type event)
+{
+ int rc = 0;
+ struct hfidd_win_event *win_event_p;
+ struct hfidd_q_event *q_event_list = NULL;
+ int num_events;
+ unsigned long flags;
+ int allocated = 0;
+
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "hfidd_report_event: enter event=0x%x p_acs=0x%p\n",
+ event, (void *) p_acs);
+
+ /*
+ * Prealloc queue event entries. We must do this because we use a
+ * lock that keeps us from allocating storage.
+ */
+ while (!allocated) {
+ num_events = atomic_read(&(win->num_events[event]));
+ q_event_list = hfidd_prealloc_q_events(p_acs, win,
+ num_events);
+ if ((q_event_list == NULL) && num_events) {
+ rc = -ENOMEM;
+ return rc;
+ }
+ spin_lock_irqsave(&(win->event_lock), flags);
+ if (num_events == atomic_read(&(win->num_events[event]))) {
+ allocated = 1;
+ } else {
+ /*
+ * The number of events we allocated for does not
+ * match the current number of events. It must
+ * have changed between the allocation and the lock.
+ * We must keep trying until we get a match.
+ */
+ spin_unlock_irqrestore(&(win->event_lock), flags);
+ hfidd_return_q_events(p_acs, &q_event_list);
+ }
+ }
+
+ /* Mark that the event has occurred and awaken each tid. */
+ for (win_event_p = win->events[event]; win_event_p != NULL;
+ win_event_p = win_event_p->next) {
+ hfidd_post_event(p_acs, win_event_p->tid_info,
+ event, event_mask[event], &q_event_list);
+ }
+ spin_unlock_irqrestore(&(win->event_lock), flags);
+ hfidd_return_q_events(p_acs, &q_event_list);
+
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "hfidd_report_event: type=0x%x rc=%d\n", event, rc);
+ return rc;
+}
+
+/* Clean up event handling when a window closes. */
+int hfidd_events_clean(struct hfidd_acs *p_acs, struct hfidd_window *win)
+{
+ int rc = 0;
+ int i;
+ struct hfidd_win_event *win_event_p;
+ struct hfidd_win_event *win_event_list = NULL;
+ struct hfidd_win_event *next_win_event_p;
+ struct hfidd_tid_info *tid_info;
+ struct hfidd_tid_info *next_tid_info;
+ struct hfidd_tid_info *tid_list = NULL;
+ int num_events;
+ unsigned long flags;
+ int allocated = 0;
+ struct hfidd_q_event *q_event_list = NULL;
+ int loop_count = 0;
+
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "hfidd_events_clean: enter p_acs=0x%p\n", (void *)p_acs);
+
+ /*
+ * Prealloc queue event entries. We must do this because we use a
+ * ock that keeps us from allocating storage.
+ */
+ while (!allocated) {
+ num_events = atomic_read(&win->num_tids);
+ q_event_list = hfidd_prealloc_q_events(p_acs, win,
+ num_events);
+ if ((q_event_list == NULL) && num_events) {
+ rc = -ENOMEM;
+ return rc;
+ }
+ spin_lock_irqsave(&(win->event_lock), flags);
+ if (num_events == atomic_read(&win->num_tids)) {
+ allocated = 1;
+ } else {
+ /*
+ * The number of events we allocated for does not
+ * match the current number of tids. It must
+ * have changed between the allocation and the lock.
+ * We must keep trying until we get a match.
+ */
+ spin_unlock_irqrestore(&(win->event_lock), flags);
+ hfidd_return_q_events(p_acs, &q_event_list);
+ }
+ }
+
+ /* Return all of the win_info structures. */
+ for (i = 0; i < HFIDD_NUM_EVENT_TYPES; i++) {
+ for (win_event_p = win->events[i]; win_event_p != NULL;
+ win_event_p = next_win_event_p) {
+ next_win_event_p = win_event_p->next;
+ win_event_p->next = win_event_list;
+ win_event_list = win_event_p;
+ }
+ win->events[i] = NULL;
+ atomic_set(&win->num_events[i], 0);
+ }
+
+ /* Return tid_info structures. */
+ for (tid_info = win->tid_list; tid_info != NULL;
+ tid_info = next_tid_info) {
+ /* Wake up the waiting task if necessary. */
+ hfidd_events_wakeup(p_acs, tid_info, &q_event_list);
+ next_tid_info = tid_info->next;
+ if (atomic_read(&win->num_tids) > 0)
+ atomic_dec(&win->num_tids);
+ tid_info->next = tid_list;
+ tid_list = tid_info;
+ }
+ win->tid_list = NULL;
+ atomic_set(&win->num_tids, 0);
+ for (i = 0; i < HFIDD_NUM_EVENT_TYPES; i++) {
+ win->funcs[i].function_p.use.kptr = NULL;
+ win->funcs[i].parameter.use.kptr = NULL;
+ }
+
+ /* Wait for all threads to finish. */
+ spin_unlock_irqrestore(&(win->event_lock), flags); /* Must disable or
+ will hang */
+ while ((atomic_read(&win->event_wait_count) > 0) &&
+ (loop_count < HFIDD_EVENT_CLEANUP_LOOP_COUNT)) {
+ set_current_state(TASK_INTERRUPTIBLE);
+ schedule_timeout(HFIDD_EVENT_CLEANUP_DELAY);
+ loop_count++;
+ }
+ atomic_set(&win->event_wait_count, 0);
+
+ return_event_list(p_acs, &win_event_list);
+ return_tid_list(p_acs, &tid_list, &q_event_list);
+ hfidd_return_q_events(p_acs, &q_event_list);
+
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "hfidd_events_clean: rc=%d\n", rc);
+ return rc;
+}
+
+int hfidd_callback_register(struct hfidd_acs *p_acs, struct hfi_reg_events *arg)
+{
+ struct hfi_reg_events reg_events;
+ struct hfidd_window *win;
+ int rc;
+
+ /* Copy in client info from user */
+ memcpy(®_events, arg, sizeof(reg_events));
+
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "hfidd_callback_register: enter type=0x%x win=0x%x "
+ "events=0x%x\n", reg_events.type, reg_events.window,
+ reg_events.info.func.index);
+
+ /* Verify inputs */
+ if (reg_events.type != FUNCTIONS_FOR_EVENTS) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_callback_register: invalid type = "
+ "0x%x\n", reg_events.type);
+ return -EINVAL;
+ }
+ if (reg_events.info.func.index == HFIDD_HFI_READY_REG) {
+ rc = hfidd_hfi_ready_registration(p_acs, ®_events);
+ return rc;
+ }
+
+ if ((reg_events.window < min_hfi_windows(p_acs)) ||
+ (reg_events.window >= max_hfi_windows(p_acs))) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_callback_register: invalid win = "
+ "0x%x\n", reg_events.window);
+ return -EINVAL;
+ }
+
+ if (reg_events.info.func.index >= HFIDD_NUM_EVENT_TYPES) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_callback_register: invalid events = "
+ "0x%x\n", reg_events.info.func.index);
+ return -EINVAL;
+ }
+
+ win = hfi_window(p_acs, reg_events.window);
+ spin_lock(&(win->win_lock));
+ if (win->state == WIN_AVAILABLE) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_callback_register: inv state "
+ "wi=0x%x st=0x%x\n",
+ win->index, win->state);
+ spin_unlock(&(win->win_lock));
+ return -EINVAL;
+ }
+ spin_unlock(&(win->win_lock));
+
+ /* fill in function pointer and parameter */
+ win->funcs[reg_events.info.func.index].function_p.use.kptr =
+ reg_events.info.func.function_p.use.kptr;
+ win->funcs[reg_events.info.func.index].parameter.use.kptr =
+ reg_events.info.func.parameter.use.kptr;
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(hfidd_callback_register);
+
+int hfidd_callback_unregister(struct hfidd_acs *p_acs,
+ struct hfi_reg_events *arg)
+{
+ struct hfi_reg_events reg_events;
+ struct hfidd_window *win;
+
+ /* Copy in client info from user */
+ memcpy(®_events, arg, sizeof(reg_events));
+
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "hfidd_callback_unregister: enter type=0x%x win=0x%x "
+ "events=0x%x\n", reg_events.type, reg_events.window,
+ reg_events.info.func.index);
+
+ /* Verify inputs */
+ if (reg_events.type != FUNCTIONS_FOR_EVENTS) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_callback_unregister: invalid type = "
+ "0x%x\n", reg_events.type);
+ return -EINVAL;
+ }
+ if (reg_events.info.func.index == HFIDD_HFI_READY_REG) {
+ hfidd_hfi_ready_unregistration(p_acs, ®_events);
+ return 0;
+ }
+
+ if ((reg_events.window < min_hfi_windows(p_acs)) ||
+ (reg_events.window >= max_hfi_windows(p_acs))) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_callback_unregister: invalid win = "
+ "0x%x\n", reg_events.window);
+ return -EINVAL;
+ }
+
+ if (reg_events.info.func.index >= HFIDD_NUM_EVENT_TYPES) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_callback_unregister: invalid events = "
+ "0x%x\n", reg_events.info.func.index);
+ return -EINVAL;
+ }
+
+ win = hfi_window(p_acs, reg_events.window);
+ spin_lock(&(win->win_lock));
+ if ((win->state != WIN_OPENED) &&
+ (win->state != WIN_ERROR) &&
+ (win->state != WIN_HERROR)) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_callback_unregister: inv state "
+ "wi=0x%x st=0x%x\n",
+ win->index, win->state);
+ spin_unlock(&(win->win_lock));
+ return -EINVAL;
+ }
+ spin_unlock(&(win->win_lock));
+
+ win->funcs[reg_events.info.func.index].function_p.use.kptr = NULL;
+ win->funcs[reg_events.info.func.index].parameter.use.kptr = NULL;
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(hfidd_callback_unregister);
+
+int hfidd_callback_event(struct hfidd_acs *p_acs, struct hfidd_window *win,
+ enum hfi_event_type event,
+ unsigned int data1,
+ unsigned int *data2_p)
+{
+ if (win->funcs[event].function_p.use.kptr == NULL) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_callback_event: NULL function ptr, "
+ "event=0x%x, win_p=0x%llx\n",
+ event, (unsigned long long)win);
+ return -EINVAL;
+ }
+
+ /* calling function */
+ ((hfi_event_func_ptr)win->funcs[event].function_p.use.kptr)
+ (win->funcs[event].parameter.use.kptr,
+ data1, data2_p);
+ return 0;
+}
+
+static int hfidd_hfi_ready_registration(struct hfidd_acs *p_acs,
+ struct hfi_reg_events *reg)
+{
+ struct hfidd_hfi_ready_req *req;
+
+ if (p_acs->state == HFI_AVAIL) {
+ /* notify kernel user */
+ return ((hfi_event_func_ptr)reg->info.func.function_p.use.kptr)
+ (reg->info.func.parameter.use.kptr, 0, 0);
+ } else {
+ /* Alloc entry */
+ req = kzalloc(sizeof(*req), GFP_KERNEL);
+ if (req == NULL) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_hfi_ready_registration: kzalloc failed\n");
+ return -ENOMEM;
+ }
+
+ /* Fill the entry for the list */
+ req->func.index = reg->info.func.index;
+ req->func.function_p.use.kptr =
+ reg->info.func.function_p.use.kptr;
+ req->func.parameter.use.kptr =
+ reg->info.func.parameter.use.kptr;
+ list_add(&(req->list), &(p_acs->hfi_ready_reg_list));
+ }
+
+ return 0;
+}
+
+static void hfidd_hfi_ready_unregistration(struct hfidd_acs *p_acs,
+ struct hfi_reg_events *reg)
+{
+ struct hfidd_hfi_ready_req *req;
+ struct list_head *q;
+ struct list_head *pos;
+
+ list_for_each_safe(pos, q, &p_acs->hfi_ready_reg_list) {
+ req = list_entry(pos,
+ struct hfidd_hfi_ready_req, list);
+ if ((req->func.function_p.use.kptr ==
+ reg->info.func.function_p.use.kptr) &&
+ (req->func.parameter.use.kptr ==
+ reg->info.func.parameter.use.kptr)) {
+ list_del(pos);
+ kfree(req);
+ break;
+ }
+ }
+
+}
+
+void hfidd_notify_hfi_ready(struct hfidd_acs *p_acs)
+{
+ struct hfidd_hfi_ready_req *req;
+ struct list_head *q;
+ struct list_head *pos;
+
+ list_for_each_safe(pos, q, &p_acs->hfi_ready_reg_list) {
+ req = list_entry(pos,
+ struct hfidd_hfi_ready_req, list);
+
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "hfidd_notify_hfi_ready: Calling Kernel user\n");
+
+ /* Calling IP function */
+ ((hfi_event_func_ptr)req->func.function_p.use.kptr)
+ (req->func.parameter.use.kptr, 0, 0);
+ list_del(pos);
+ kfree(req);
+ }
+}
diff --git a/drivers/net/hfi/core/hfidd_init.c b/drivers/net/hfi/core/hfidd_init.c
index 783ce1b..0f3616a 100644
--- a/drivers/net/hfi/core/hfidd_init.c
+++ b/drivers/net/hfi/core/hfidd_init.c
@@ -180,6 +180,40 @@ static ssize_t hfidd_cmd_write(struct file *filep, const char __user *buf,
(struct hfi_window_info *) buf);
break;
+ case HFIDD_REQ_EVENT_REGISTER:
+ if (cmd.req_len != sizeof(struct hfi_reg_events)) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_cmd_write: hdr.reqlen 0x%x expected "
+ "0x%lx for cmd req 0x%x\n",
+ cmd.req_len,
+ sizeof(struct hfi_reg_events), cmd.req);
+ return -EINVAL;
+ }
+ if (is_userspace)
+ rc = hfidd_events_register(p_acs,
+ (struct hfi_reg_events *) buf);
+ else
+ rc = hfidd_callback_register(p_acs,
+ (struct hfi_reg_events *) buf);
+ break;
+
+ case HFIDD_REQ_EVENT_UNREGISTER:
+ if (cmd.req_len != sizeof(struct hfi_reg_events)) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_cmd_write: hdr.reqlen 0x%x expected "
+ "0x%lx for cmd req 0x%x\n",
+ cmd.req_len,
+ sizeof(struct hfi_reg_events), cmd.req);
+ return -EINVAL;
+ }
+ if (is_userspace)
+ rc = hfidd_events_unregister(p_acs,
+ (struct hfi_reg_events *) buf);
+ else
+ rc = hfidd_callback_unregister(p_acs,
+ (struct hfi_reg_events *) buf);
+ break;
+
case HFIDD_REQ_QUERY_DD_INFO:
if (cmd.req_len != sizeof(struct hfi_query_dd_info)) {
dev_printk(KERN_ERR, p_acs->hfidd_dev,
@@ -349,6 +383,7 @@ int hfidd_init_adapter(struct hfidd_acs *p_acs, void *uiop)
{
int rc = 0;
+ INIT_LIST_HEAD(&(p_acs->hfi_ready_reg_list));
rc = hfidd_dds_init(p_acs, &(p_acs->dds));
p_acs->dds.num_d_windows = HFI_DYN_WINS_DEFAULT;
return rc;
diff --git a/drivers/net/hfi/core/hfidd_intr.c b/drivers/net/hfi/core/hfidd_intr.c
index 253de27..38f35f5 100644
--- a/drivers/net/hfi/core/hfidd_intr.c
+++ b/drivers/net/hfi/core/hfidd_intr.c
@@ -33,15 +33,45 @@
#include <linux/hfi/hfidd_internal.h>
#include "hfidd_proto.h"
+/* Post window event */
+static int hfidd_post_window_event(struct hfidd_acs *p_acs,
+ struct hfidd_window *win_p, enum hfi_event_type event)
+{
+ int rc = 0;
+
+ if (win_p->state == WIN_OPENED) {
+ if (win_p->funcs[event].function_p.use.kptr != NULL) {
+ rc = hfidd_callback_event(p_acs, win_p, event,
+ win_p->index, 0);
+ } else {
+ rc = hfidd_report_event(p_acs, win_p, event);
+ }
+ if (rc) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_post_window_event: failed to "
+ "post event %d win 0x%x rc 0x%x\n",
+ event, win_p->index, rc);
+ }
+ }
+ return rc;
+}
+
static irqreturn_t send_intr_handler(int irq, void *data)
{
struct hfidd_window *win_p = data;
struct hfidd_acs *p_acs;
+ int rc;
p_acs = hfidd_global.p_acs[win_p->ai];
if (p_acs == NULL)
return IRQ_HANDLED;
-
+ rc = hfidd_post_window_event(p_acs, win_p, HFIDD_SEND);
+ if (rc) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "send_intr_handler: failed post send event, "
+ "rc %d for win 0x%llx\n",
+ rc, (unsigned long long) win_p);
+ }
return IRQ_HANDLED;
}
@@ -49,11 +79,19 @@ static irqreturn_t recv_intr_handler(int irq, void *data)
{
struct hfidd_window *win_p = data;
struct hfidd_acs *p_acs;
+ int rc;
p_acs = hfidd_global.p_acs[win_p->ai];
if (p_acs == NULL)
return IRQ_HANDLED;
+ rc = hfidd_post_window_event(p_acs, win_p, HFIDD_RECV);
+ if (rc) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "recv_intr_handler: failed post recv event, "
+ "rc %d for win 0x%llx\n",
+ rc, (unsigned long long) win_p);
+ }
return IRQ_HANDLED;
}
diff --git a/drivers/net/hfi/core/hfidd_proto.h b/drivers/net/hfi/core/hfidd_proto.h
index af88f0b..89f9639 100644
--- a/drivers/net/hfi/core/hfidd_proto.h
+++ b/drivers/net/hfi/core/hfidd_proto.h
@@ -73,6 +73,20 @@ int hfidd_query_interface(struct hfidd_acs *p_acs, unsigned int subtype,
int hfidd_start_nmmu(struct hfidd_acs *p_acs);
int hfidd_start_interface(struct hfidd_acs *p_acs);
int hfidd_stop_interface(struct hfidd_acs *p_acs, unsigned int hfi_id);
+int hfidd_events_register(struct hfidd_acs *p_acs, struct hfi_reg_events *arg);
+int hfidd_events_unregister(struct hfidd_acs *p_acs,
+ struct hfi_reg_events *arg);
+int hfidd_callback_register(struct hfidd_acs *p_acs,
+ struct hfi_reg_events *arg);
+int hfidd_callback_unregister(struct hfidd_acs *p_acs,
+ struct hfi_reg_events *arg);
+int hfidd_report_event(struct hfidd_acs *p_acs, struct hfidd_window *win,
+ enum hfi_event_type event);
+int hfidd_callback_event(struct hfidd_acs *p_acs, struct hfidd_window *win,
+ enum hfi_event_type event, unsigned int data1,
+ unsigned int *data2_p);
+int hfidd_events_clean(struct hfidd_acs *p_acs, struct hfidd_window *win);
+void hfidd_notify_hfi_ready(struct hfidd_acs *p_acs);
int hfidd_init_win_interrupt(struct hfidd_acs *p_acs,
struct hfidd_window *win_p);
void hfidd_clear_win_interrupt(struct hfidd_window *win_p);
@@ -104,5 +118,5 @@ long long hfi_hquery_interface(u64 unit_id, u64 subtype, u64 query_p,
u64 *state);
long long hfi_start_interface(u64 unit_id);
long long hfi_stop_interface(u64 unit_id);
-
+long long hfi_query_window(u64 unit_id, u64 win_id, u64 *state);
#endif
diff --git a/drivers/net/hfi/core/hfidd_window.c b/drivers/net/hfi/core/hfidd_window.c
index 6864eae..1d7f2b1 100644
--- a/drivers/net/hfi/core/hfidd_window.c
+++ b/drivers/net/hfi/core/hfidd_window.c
@@ -314,6 +314,8 @@ static inline int hfi_validate_window_id(struct hfidd_acs *p_acs,
static inline void hfi_restore_window_parm(struct hfidd_acs *p_acs,
struct hfidd_window *win_p)
{
+ int i;
+
if (win_p->type != HFIDD_RESERVE_WIN) {
win_p->type = HFIDD_DYNAMIC_WIN;
win_p->job_id = 0;
@@ -325,6 +327,12 @@ static inline void hfi_restore_window_parm(struct hfidd_acs *p_acs,
}
win_p->pid = 0;
win_p->is_ip = 0;
+
+
+ for (i = 0; i < HFIDD_NUM_EVENT_TYPES; i++) {
+ win_p->funcs[i].function_p.use.kptr = NULL;
+ win_p->funcs[i].parameter.use.kptr = NULL;
+ }
}
/* Validate window number and type for open window request */
@@ -1074,6 +1082,13 @@ int hfidd_open_window_func(struct hfidd_acs *p_acs, unsigned int is_userspace,
win_p->state = WIN_OPENED;
spin_unlock(&(win_p->win_lock));
+ /*
+ * Increment so that any waiting threads that wake up realize
+ * they are dealing with a window that has been reopened
+ */
+ atomic_inc(&win_p->open_close_count);
+ hfidd_events_clean(p_acs, win_p);
+
kfree(local_p);
return rc;
@@ -1129,6 +1144,12 @@ int hfidd_close_window_internal(struct hfidd_acs *p_acs,
goto hfidd_close_window_internal_err0;
}
+ /* Wake up threads waiting for terminate event. */
+ rc = hfidd_report_event(p_acs, win_p, HFIDD_TERMINATE);
+ if (rc)
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "close_window_internal: report event failed "
+ "rc=0x%x\n", rc);
spin_lock(&(win_p->win_lock));
/* Make sure state is open or error state. */
@@ -1183,6 +1204,9 @@ int hfidd_close_window_internal(struct hfidd_acs *p_acs,
hfi_restore_window_parm(p_acs, win_p);
spin_unlock(&win_p->win_lock);
+ atomic_inc(&win_p->open_close_count);
+ hfidd_events_clean(p_acs, win_p);
+
dev_printk(KERN_INFO, p_acs->hfidd_dev,
"close_window_internal: type=0x%x state=0x%x JobID=0x%x\n",
win_p->type, win_p->state, win_p->job_id);
diff --git a/include/linux/hfi/hfidd_client.h b/include/linux/hfi/hfidd_client.h
index 3b2d032..7f87674 100644
--- a/include/linux/hfi/hfidd_client.h
+++ b/include/linux/hfi/hfidd_client.h
@@ -97,6 +97,9 @@ struct fifo_info {
#define HFIDD_RESERVE_WIN 3 /* Must be reserved by job scheduler */
#define HFIDD_DYNAMIC_WIN 4 /* First come, first served. Window# is
returned */
+#define HFIDD_DST_BCST_WIN 0
+#define HFIDD_DST_BCST_ISR 0x3FFF
+
struct hfi_client_info {
struct hfi_req_hdr hdr;
@@ -138,6 +141,67 @@ enum hfi_event_type {
HFIDD_NUM_EVENT_TYPES = 12
};
+#define HFIDD_SEND_EVENT 0x00000100
+#define HFIDD_RECV_EVENT 0x00000200
+#define HFIDD_WIN_ERROR_EVENT 0x00000400
+#define HFIDD_HFI_ERROR_EVENT 0x00000800
+#define HFIDD_TERMINATE_EVENT 0x00001000
+#define HFIDD_RELEASE_WINDOW_EVENT 0x00002000
+#define HFIDD_CAU_ERROR_EVENT 0x00004000
+#define HFIDD_ICS_ERROR_EVENT 0x00008000
+#define HFIDD_HFI_READY_REG_EVENT 0x00010000
+#define HFIDD_ROUTE_CHANGE_EVENT 0x00020000
+#define HFIDD_IP_TRC_LVL_EVENT 0x00040000
+#define HFIDD_POOL_SIZE_EVENT 0x00080000
+#define HFIDD_LOWEST_EVENT HFIDD_SEND_EVENT
+#define HFIDD_ALL_EVENTS 0x000FFF00
+
+enum hfi_event_hndlr_type {
+ WAIT_FOR_EVENTS = 1, /* Wait for events */
+ SIGNAL_EVENTS = 2, /* Event notification by signal */
+ FUNCTIONS_FOR_EVENTS = 3 /* Callback functions */
+};
+
+typedef int (*hfi_event_func_ptr)(void *parm, unsigned int win,
+ unsigned int *ext);
+
+struct hfi_callback_func { /* Callback funcs for kernel windows */
+ enum hfi_event_type index; /* index of callback type */
+ unsigned int pad;
+ struct hfi_64b function_p; /* function ptr */
+ struct hfi_64b parameter; /* parameter to pass in */
+};
+
+/*
+ * HFIDD_REQ_EVENT_REGISTER/HFIDD_REQ_EVENT_UNREGISTER: event
+ * registration/unregistration
+ */
+#define HFI_MAX_BUF_EVENTS 8 /* # event buffers for signal version */
+struct hfi_event_buffer { /* For reporting events with signals */
+ unsigned int tag;
+ enum hfi_event_type current_event;
+};
+
+struct hfi_reg_events {
+ struct hfi_req_hdr hdr;
+ unsigned int window;
+ enum hfi_event_hndlr_type type;
+ union {
+ unsigned int events;
+ struct hfi_callback_func func;
+ struct hfi_64b eb; /* Pointer to event buffer in
+ user space (signal only) */
+ } info;
+};
+
+/* HFIDD_REQ_EVENT_WAIT: wait on event */
+struct hfi_wait_events {
+ struct hfi_req_hdr hdr;
+ unsigned int window; /* Window for events */
+ unsigned int events; /* events to wait for */
+ unsigned int out_events; /* events received */
+};
+
#define MAX_TORRENTS 1
#define MAX_HFI_PER_TORRENT 2
#define MAX_HFIS (MAX_TORRENTS * MAX_HFI_PER_TORRENT)
diff --git a/include/linux/hfi/hfidd_internal.h b/include/linux/hfi/hfidd_internal.h
index e96142a..18f0fb4 100644
--- a/include/linux/hfi/hfidd_internal.h
+++ b/include/linux/hfi/hfidd_internal.h
@@ -72,6 +72,16 @@
#define HFIDD_DEV_NAME "hfi"
#define HFIDD_CLASS_NAME "hfi"
+#define HFIDD_EVENT_CLEANUP_LOOP_COUNT 1000
+#define HFIDD_EVENT_CLEANUP_DELAY 10
+
+/* window event */
+struct hfidd_q_event {
+ struct list_head list;
+ struct hfidd_q_event *next; /* For preallocation list */
+ unsigned int event;
+};
+
struct hfidd_dds {
unsigned int version; /* HFI adapter type */
unsigned long long misc_base_address; /* Misc user base address */
@@ -83,6 +93,33 @@ struct hfidd_dds {
unsigned long long fw_ec_level; /* Firmware Level */
};
+struct hfidd_tid_info {
+ struct hfidd_tid_info *next;
+ unsigned long long tid; /* Thread id */
+ struct semaphore tid_sem;
+ unsigned int registered_events;
+ unsigned int deferred_events;/* Events that have occurred
+ but have not yet been
+ reported */
+ enum hfi_event_hndlr_type type;
+ struct list_head event_list; /* List of hfidd_event */
+ wait_queue_head_t event_wait; /* Used to wait and post
+ threads */
+ unsigned int tag; /* Used with eb */
+ struct task_struct *eb_xd; /* For cross task write */
+ struct hfi_event_buffer *eb; /* Pointer to event
+ buffer location in
+ user space (for
+ signal handling) */
+ struct task_struct *th; /* task_struct associated with
+ tid */
+};
+
+struct hfidd_win_event {
+ struct hfidd_win_event *next;
+ struct hfidd_tid_info *tid_info;
+};
+
struct hfidd_fifo {
unsigned long long eaddr;
unsigned long long size;
@@ -92,6 +129,7 @@ struct hfidd_fifo {
struct hfidd_window {
spinlock_t win_lock; /* lock for window */
+ spinlock_t event_lock; /* lock for event handling */
int index;
unsigned int type; /* dynamic/scheduled */
int state;
@@ -117,10 +155,40 @@ struct hfidd_window {
OPEN_WINDOW hcall */
unsigned long long mmio_regs; /* logical addr from
OPEN WINDOW hcall */
+ atomic_t open_close_count; /*Incremented every time
+ a window is opened or
+ closed. This is used for
+ event handling to determine
+ if a close occurred while
+ waiting. */
+ struct hfi_callback_func funcs[HFIDD_NUM_EVENT_TYPES]; /* Callback
+ funcs for IP */
+ struct hfidd_win_event *events[HFIDD_NUM_EVENT_TYPES]; /* Each
+ array entry points to a
+ list. Each list entry
+ contains a tid that should
+ be posted when this event
+ occurs. */
+ atomic_t num_events[HFIDD_NUM_EVENT_TYPES]; /* Number
+ of elements in each of the
+ events lists */
+ struct hfidd_tid_info *tid_list; /* List of tids registered for
+ events on this window */
+ atomic_t num_tids; /* Number of tids in
+ tid_list */
+ atomic_t event_wait_count;/* Indicates how many
+ threads are waiting for
+ events on this window */
struct hfidd_vlxmem *sfifo_x_tab;
struct hfidd_vlxmem *rfifo_x_tab;
};
+struct hfidd_hfi_ready_req {
+ struct list_head list;
+ struct hfi_callback_func func;
+};
+
+
#define HFI_DEVICE_NAME_MAX 64
/* hfi global */
struct hfidd_acs {
@@ -131,6 +199,7 @@ struct hfidd_acs {
unsigned int state;
unsigned int isr;
+ struct list_head hfi_ready_reg_list;
struct hfidd_window **win;
struct device *hfidd_dev;
diff --git a/include/linux/hfi/hfidd_requests.h b/include/linux/hfi/hfidd_requests.h
index a7a38da..002ae7f 100644
--- a/include/linux/hfi/hfidd_requests.h
+++ b/include/linux/hfi/hfidd_requests.h
@@ -37,4 +37,7 @@
#define HFIDD_REQ_QUERY_DD_INFO 0x00001004
#define HFIDD_REQ_CLOSE_WINDOW 0x00000a02
+#define HFIDD_REQ_EVENT_REGISTER 0x00000702
+#define HFIDD_REQ_EVENT_UNREGISTER 0x00000703
+
#endif /* _HFIDD_REQUESTS_H_ */
--
1.7.3.5
^ permalink raw reply related
* [PATCH v2 23/27] HFI: Define packet header formats and window register offsets
From: dykmanj @ 2011-04-18 3:21 UTC (permalink / raw)
To: netdev
Cc: Jim Dykman, Piyush Chaudhary, Fu-Chung Chang, William S. Cadden,
Wen C. Chen, Scot Sakolish, Jian Xiao, Carol L. Soto,
Sarah J. Sheppard
In-Reply-To: <1303096919-7367-1-git-send-email-dykmanj@linux.vnet.ibm.com>
From: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Piyush Chaudhary <piyushc@linux.vnet.ibm.com>
Signed-off-by: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
Signed-off-by: William S. Cadden <wscadden@linux.vnet.ibm.com>
Signed-off-by: Wen C. Chen <winstonc@linux.vnet.ibm.com>
Signed-off-by: Scot Sakolish <sakolish@linux.vnet.ibm.com>
Signed-off-by: Jian Xiao <jian@linux.vnet.ibm.com>
Signed-off-by: Carol L. Soto <clsoto@linux.vnet.ibm.com>
Signed-off-by: Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
---
include/linux/hfi/hfidd_pkt_formats.h | 338 +++++++++++++++++++++++++++++++++
include/linux/hfi/hfidd_regs.h | 212 +++++++++++++++++++++
2 files changed, 550 insertions(+), 0 deletions(-)
create mode 100644 include/linux/hfi/hfidd_pkt_formats.h
create mode 100644 include/linux/hfi/hfidd_regs.h
diff --git a/include/linux/hfi/hfidd_pkt_formats.h b/include/linux/hfi/hfidd_pkt_formats.h
new file mode 100644
index 0000000..ee8d385
--- /dev/null
+++ b/include/linux/hfi/hfidd_pkt_formats.h
@@ -0,0 +1,338 @@
+/*
+ * hfidd_pkt_formats.h
+ *
+ * HFI device driver for IBM System p
+ *
+ * Authors:
+ * Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
+ * William S. Cadden <wscadden@linux.vnet.ibm.com>
+ * Wen C. Chen <winstonc@linux.vnet.ibm.com>
+ * Scot Sakolish <sakolish@linux.vnet.ibm.com>
+ * Jian Xiao <jian@linux.vnet.ibm.com>
+ * Carol L. Soto <clsoto@linux.vnet.ibm.com>
+ * Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
+ *
+ * (C) Copyright IBM Corp. 2010
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#ifndef _HFI_PKT_FORMATS_H
+#define _HFI_PKT_FORMATS_H
+
+#define HFI_HW_DIRECT_ROUTE 0
+#define HFI_SW_INDIRECT_ROUTE 1
+#define HW_DIRECT_STRIPING_ROUTE 2
+#define HW_INDIRECT_STRIPING_ROUTE 3
+
+/* HFI packet header format */
+
+struct immediate_send_hdr {
+ unsigned int reserved1:8;
+ unsigned int cop_type:8; /* HFI coprocessor type is 0x3A */
+ unsigned int reserved2:7;
+ unsigned int src_win:9; /* Hi bit is hfi# */
+} __packed;
+
+struct packet_type_hdr {
+ unsigned int header_type:7; /* See hfi_packet_type for types */
+ unsigned int send_origin:1; /* 0: from Send/RDMA FIFO */
+ /* 1: from Immediate Send */
+} __packed;
+
+struct base_hdr {
+ unsigned int reserve1:1;
+ unsigned int dst_isr:14; /* destination ISR */
+ unsigned int dst_win:9; /* destination window.
+ Hi bit is hfi num */
+ unsigned int reserve2:1;
+
+ unsigned int src_isr:14; /* src ISR, Set by hardware */
+ unsigned int src_win:9; /* src window, Set by hardware.
+ Hi bit is hfi num */
+ unsigned int src_cau:1;
+ unsigned int dst_cau:1;
+ unsigned int reserve3:2;
+
+ unsigned int pkt_len:4; /* In cache lines. 0 means 16 */
+ unsigned int reserve4:8;
+ unsigned int trc_enable:1; /* Request ISR trace info
+ send/recv, IP packest only */
+ unsigned int ctr_incr:1; /* Request send and receive
+ counter increments */
+ unsigned int sii:1; /* Source Side Immediate Int */
+ unsigned int dii:1; /* Dest Side Immediate Int */
+ unsigned int reserve5:3;
+ unsigned int pkt_valid:1; /* Set by hardware
+ Toggles when rFIFO wraps */
+ unsigned int status:5; /* Set by hardware completion status */
+ unsigned int route_control:2;/* ISR use only */
+ unsigned int ind_node:9; /* ISR use only */
+} __packed;
+
+struct hfi_rdma_extended_hdr { /* 48B */
+ unsigned long long source_ea; /* Full RDMA only, byte
+ boundary */
+ unsigned long long dest_ea; /* byte boundary, independent of
+ source data boundary */
+ unsigned int pkt_len:4; /* In cache lines, with
+ exceptions */
+ unsigned int reserved1:3;
+ unsigned int msg_len:25; /* In bytes.
+ FullRDMA: Max 32MB
+ (encoded as 0)
+ HalfRDMA: Max 2kB
+ SmallRDMA: Max 16B */
+ unsigned int reserved2:5;
+ unsigned int rcxt_offset:20; /* into window's rcxt area */
+ unsigned int reserved3:1;
+ unsigned int breakup:6; /* Message Breakup count */
+ unsigned int epoch:32;
+ unsigned int seq_num:14;
+ unsigned int pkt_cnt:18; /* FullRDMA only */
+ unsigned int reserved4:3;
+ unsigned int rcxt_index:5; /* 1-31 allowed */
+ unsigned int read_indicator:1; /* 1 for FULL RDMA reads */
+ unsigned int src_completion:1;
+ unsigned int src_completion_notify:1;
+ unsigned int dst_completion_notify:1;
+ unsigned int status:5; /* Notification packet only. */
+ unsigned int reserved6:3;
+ unsigned int fetch:1; /* SmallRDMA only. */
+ unsigned int opcode:3;
+ unsigned int reserved7:8;
+ unsigned int reserved8:32;
+ unsigned long long cookie; /* Protocol cookie */
+} __packed;
+
+struct gups_rdma_element { /* 32B. Used without Base
+ header */
+ unsigned int job_id:32;
+ unsigned int header_type:7; /* Use GUPS types only */
+ unsigned int reserved1:2;
+ unsigned int dst_isr:14; /* destination ISR */
+ unsigned int dst_win:9; /* destination window.
+ Hi bit is hfi# */
+ unsigned int reserved2:15;
+ unsigned int ctr_incr:1; /* Request send and receive
+ counter increments */
+ unsigned int isr_route_hdr:16; /* ISR use only */
+ unsigned int reserved3:32;
+
+ union {
+ unsigned long long addr;
+ struct {
+ unsigned int dest_ea_hi:32;
+ unsigned int dest_ea_lo:29; /* 8-byte align */
+ unsigned int opcode:3; /* Use HFI_OPCODE* */
+ } bits;
+ } dest_ea;
+
+ unsigned long long payload;
+} __packed;
+
+struct hfi_cau_extended_hdr { /* 32B */
+ unsigned int group_id:27;
+ unsigned int dst_sub_id:9;
+ unsigned int src_sub_id:9;
+ unsigned int reserved1:3;
+ unsigned int op_attr_unsigned:1; /* 0->Signed */
+ unsigned int op_attr_64bit:1; /* 0->32 bit */
+ unsigned int op_attr_float:1; /* 0->Fixed */
+ unsigned int function:5;
+ unsigned int payload_cnt:8; /* bitmask */
+ unsigned int seq_num:32;
+ unsigned int reserved2:6;
+ unsigned int entry:1; /* 0->A, 1->B */
+ unsigned int reserved3:25;
+ unsigned long long cookie_left; /* Protocol Cookie */
+ unsigned long long cookie_right;
+} __packed;
+
+struct hfi_hdr {
+ union {
+ struct immediate_send_hdr immediate_hdr;
+ unsigned int job_id;
+ } id;
+
+ struct packet_type_hdr type;
+ struct base_hdr base_hdr;
+} __packed;
+
+struct hfi_rdma_hdr {
+ struct hfi_hdr hfi_hdr;
+ struct hfi_rdma_extended_hdr rdma_ext;
+ /*
+ * Pad enough for the payload to be aligned with the dest address.
+ * SmallRDMA: no padding FullRDMA: packets 2-N pad 64 bytes
+ */
+} __packed;
+
+
+struct hfi_rdma_pkt {
+ struct hfi_hdr hfi_hdr;
+ struct hfi_rdma_extended_hdr rdma_ext;
+ /*
+ * Pad enough for the payload to be aligned with the dest address.
+ * SmallRDMA: no padding FullRDMA: packets 2-N pad 64 bytes
+ */
+ char padding_slash_payload[1984];
+} __packed;
+
+
+#define CACHE_LINE_SIZE 0x80
+#define CACHE_LINE_SHIFT 0x7
+/*
+ * Encode/Decode macros/inlines for bit fields
+ */
+static inline unsigned int hfi_bytes_to_cacheline(unsigned int bytes)
+{
+ return (bytes + (CACHE_LINE_SIZE - 1)) >> CACHE_LINE_SHIFT;
+}
+
+static inline unsigned int HFI_CACHELINES_TO_BYTES(unsigned int cache_lines)
+{
+ return cache_lines << CACHE_LINE_SHIFT;
+}
+
+static inline unsigned int hfi_cachelines_to_pktlen(unsigned int cachelines)
+{
+ return cachelines & 0xf; /* No overflow checking */
+}
+
+static inline unsigned int hfi_pktlen_to_cachelines(unsigned int pktlen)
+{
+ return pktlen ? pktlen : 16; /* 0 pktlen == 16 cache lines */
+}
+
+struct hfi_gups_rdma_pkt {
+ struct gups_rdma_element element[4];
+} __packed;
+
+struct hfi_collective_pkt {
+ struct hfi_hdr hfi_hdr;
+ struct hfi_cau_extended_hdr cau_ext;
+ char payload[64];
+ char pad[16];
+} __packed;
+
+/*
+ * Opcodes for RDMA Extended Headers and GUPS-RDMA Elements
+ */
+#define HFI_OPCODE_ADD 0x0
+#define HFI_OPCODE_AND 0x1
+#define HFI_OPCODE_OR 0x2
+#define HFI_OPCODE_XOR 0x3
+#define HFI_OPCODE_RESERVED 0x4
+#define HFI_OPCODE_CMP_SWAP_NOT_EQUAL 0x5
+#define HFI_OPCODE_CMP_SWAP_EQUAL 0x6
+#define HFI_OPCODE_SWAP 0x7
+/* Fetch can be OR'd with any of the above Opcodes (SmallRDMA only) */
+#define HFI_OPCODE_FETCH 0x8
+
+enum hfi_cau_type {
+ HFI_CAU_TYPE_FLOAT = 0x01,
+ HFI_CAU_TYPE_64BIT = 0x02,
+ HFI_CAU_TYPE_UNSIGNED = 0x04
+};
+
+enum hfi_cau_function {
+ HFI_CAU_FUNCTION_NOP = 0x00,
+ HFI_CAU_FUNCTION_SUM = 0x01,
+ HFI_CAU_FUNCTION_MIN = 0x02,
+ HFI_CAU_FUNCTION_MAX = 0x03,
+ HFI_CAU_FUNCTION_AND = 0x11,
+ HFI_CAU_FUNCTION_XOR = 0x16,
+ HFI_CAU_FUNCTION_OR = 0x17
+};
+
+enum hfi_pkt_status {
+ HFI_PKT_STATUS_GOOD = 0x0,
+ HFI_PKT_STATUS_DESCRIPTOR_FAILURE = 0x1,
+ HFI_PKT_STATUS_PACKET_KILLED = 0x2,
+ HFI_PKT_STATUS_UNEXPECTED_LAST_FLIT = 0x4,
+ HFI_PKT_STATUS_POWERBUS_MASTER = 0x8,
+ HFI_PKT_STATUS_TRANSLATION_FAULT = 0x10
+
+};
+
+enum hfi_rdma_pkt_status {
+ HFI_RDMA_PKT_STATUS_GOOD = 0x0,
+ HFI_RDMA_PKT_STATUS_MIGRATION_CONFLICT = 0x1,
+ HFI_RDMA_PKT_STATUS_PACKET_KILLED = 0x4,
+ HFI_RDMA_PKT_STATUS_POWERBUS_MASTER = 0x8,
+ HFI_RDMA_PKT_STATUS_TRANSLATION_FAULT = 0x10
+
+};
+
+enum hfi_packet_type {
+ HFI_SEND_RECEIVE = 0x00, /* send FIFO -> receive
+ FIFO */
+
+ HFI_IP_WITH_PAYLOAD = 0x08, /* send FIFO -> receive
+ FIFO for IP */
+ HFI_IP_MULTICAST_WITH_PAYLOAD = 0x09, /* ISR use only */
+ HFI_IP_WITH_DESCRIPTORS = 0x0C, /* IP send/recv with
+ indirection */
+ HFI_IP_MULTICAST_WITH_DESCRIPTORS = 0x0D, /* IP send/recv with
+ indirection */
+
+ HFI_FULL_RDMA_WRITE = 0x10,
+ HFI_FULL_RDMA_READ = 0x11,
+ HFI_FULL_RDMA_COMPLETION = 0x12, /* Completion
+ notification */
+ HFI_FULL_RDMA_PREFENCE = 0x13, /* Guarantee RDMA FIFO
+ processing is
+ complete */
+ HFI_FULL_RDMA_FENCE = 0x14, /* Guarantee RDMA FIFO
+ processing is
+ complete */
+ HFI_FULL_RMDA_WRITE_ALIAS = 0x15, /* HW use only */
+
+ HFI_HALF_RDMA_WRITE = 0x18, /* send FIFO to target
+ EA */
+ HFI_HALF_RDMA_READ = 0x19, /* target EA to receive
+ FIFO */
+ HFI_HALF_RDMA_COMPLETION = 0x1A, /* Completion
+ notification */
+ HFI_HALF_RDMA_READ_ALIAS = 0x1D, /* HW use only */
+
+ HFI_SMALL_RDMA_WRITE = 0x20, /* Remote atomic
+ operations */
+ HFI_SMALL_RDMA_COMPLETION = 0x22, /* Completion
+ notification */
+ HFI_SMALL_RDMA_COMPLETION_WITH_FETCH = 0x23, /* Completion
+ notification */
+
+ HFI_GUPS_RDMA_1ELEMENT = 0x28, /* GUPS-RDMA, 1
+ element */
+ HFI_GUPS_RDMA_2ELEMENT = 0x29, /* GUPS-RDMA,
+ 2 element */
+ HFI_GUPS_RDMA_3ELEMENT = 0x2A, /* GUPS-RDMA, 3
+ element */
+ HFI_GUPS_RDMA_4ELEMENT = 0x2B, /* GUPS-RDMA, 4
+ element */
+
+ HFI_CAU_REDUCE = 0x30, /* Collective Reduce */
+ HFI_CAU_MULTICAST = 0x31, /* Collective
+ Multicast */
+ HFI_CAU_ACK = 0x32, /* Collective Ack */
+ HFI_CAU_RETRANS_REQ = 0x33, /* Collective
+ Retransmit Req */
+ HFI_LAST_HEADER
+};
+
+#endif /* _HFI_PKT_FORMATS_H */
diff --git a/include/linux/hfi/hfidd_regs.h b/include/linux/hfi/hfidd_regs.h
new file mode 100644
index 0000000..864e0e6
--- /dev/null
+++ b/include/linux/hfi/hfidd_regs.h
@@ -0,0 +1,212 @@
+/*
+ * hfidd_regs.h
+ *
+ * HFI device driver for IBM System p
+ *
+ * Authors:
+ * Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
+ * William S. Cadden <wscadden@linux.vnet.ibm.com>
+ * Wen C. Chen <winstonc@linux.vnet.ibm.com>
+ * Scot Sakolish <sakolish@linux.vnet.ibm.com>
+ * Jian Xiao <jian@linux.vnet.ibm.com>
+ * Carol L. Soto <clsoto@linux.vnet.ibm.com>
+ * Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
+ *
+ * (C) Copyright IBM Corp. 2010
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#ifndef HFIDD_REGS_H
+#define HFIDD_REGS_H
+
+/* MMIO Registers */
+/* These are the registers with User Privilege Level */
+
+/* Window Control */
+#define HFI_JOB_ID_SEND 0x0000 /* 32: Send Side Job ID */
+#define HFI_JOB_ID_RECV 0x0008 /* 32: Send Side Job ID */
+#define HFI_WINDOW_STATE 0x0010 /* 1: 0=closed, 1=active */
+#define HFI_SEND_BUSY 0x0020 /* Send Window Busy */
+#define HFI_RECV_BUSY 0x0028 /* Rcv Window Busy */
+
+/* Addr Translation */
+#define HFI_LPAR_ID 0x0040 /* 10: Partition ID */
+#define HFI_PROTECTION_DOMAIN 0x0048 /* 32: used for addr xlat */
+#define HFI_XLAT_BYPASS 0x0050 /* 1: */
+
+/* Imm Send */
+#define HFI_IMM_SEND_BUF_ATTRBS 0x0080 /* 40: Immed Send Buffer Attributes */
+#define HFI_IMM_BUF_INUSE 0x0090 /* Immed Send Buffers In Use */
+#define HFI_IMM_FINI_COUNT 0x00A0 /* Immed Send Buffer Finished Count */
+#define HFI_IMM_FINI_FREQUENCY 0x00A8 /* Immed Send Finished Frequency */
+
+/* Send Fifo */
+#define HFI_SFIFO_DB_REG 0x0110 /* 16: Send Fifo Doorbell */
+#define HFI_SFIFO_BASE_ADDR 0x0120 /* 64: Send Fifo Effective Addr */
+#define HFI_SFIFO_LKEY 0x0128 /* 32: Send Fifo Local Key */
+#define HFI_SFIFO_PULL_OFF 0x0140 /* 64: Send Fifo Pull Offset */
+#define HFI_SFIFO_SIZE 0x0148 /* 4: size from 4K to 8M */
+#define HFI_SFIFO_PEND_COUNT 0x0150 /* 16: Send Fifo Pending Count */
+#define HFI_SFIFO_FINI_POLARITY 0x0158 /* 1: Send Fifo Finish Polarity Bit */
+#define HFI_SFIFO_FINI_ADDR 0x0180 /* 64: Send Fifo Finish Effective
+ Addr */
+#define HFI_IMM_FINI_ADDR 0x0188 /* Immed Send Finished Address */
+#define HFI_SFIFO_INTR_CNTL 0x01C8 /* xx: Send Fifo Interrupt Control */
+
+/* Full-RDMA Send Fifo */
+#define HFI_FRDMA_DB_REG 0x0210 /* Full-RDMA Send Fifo Doorbell */
+#define HFI_FRDMA_BASE_ADDR 0x0220 /* Full-RDMA Send Fifo Effective
+ Address */
+#define HFI_FRDMA_LKEY 0x0228 /* Full-RDMA Send Fifo Local Key */
+#define HFI_FRDMA_PULL_REG 0x0240 /* Full-RDMA Send Fifo Pull Offset */
+#define HFI_FRDMA_SIZE 0x0248 /* Full-RDMA Send Size */
+#define HFI_FRDMA_PEND_REG 0x0250 /* Full-RDMA Send Fifo Pending Count */
+#define HFI_FRDMA_FINI_POLARITY 0x0248 /* Full-RDMA Send Fifo Finished
+ Polarity */
+#define HFI_FRDMA_BREAKUP_REG 0x0260 /* Full-RDMA Send Fifo Breakup Count */
+#define HFI_FRDMA_FINI_ADDR 0x0280 /* Full-RDMA Send Fifo Finished
+ Address */
+#define HFI_FRDMA_INTR_REG 0x02C8 /* Full-RDMA Send Fifo Interrupt
+ Control */
+#define HFI_FRDMA_FENCE_CNT 0x0578 /* Full-RDMA Send Fifo Fence Count */
+
+/* Send Interrupts */
+#define HFI_SINTR_CONTROL_REG 0x02E0 /* Send Force Interrupt Control */
+#define HFI_SINTR_STATUS_REG 0x02E8 /* Send Intr Status */
+
+/* Receive Fifo */
+#define HFI_RFIFO_INC_FSLOT_REG 0x0310 /* Receive Fifo Inc Free Slot Count */
+#define HFI_RFIFO_BASE_ADDR 0x0320 /* Receive Fifo Effective Address */
+#define HFI_RFIFO_LKEY 0x0328 /* Receive Fifo Local Key */
+#define HFI_RFIFO_PUSH_REG 0x0340 /* Receive Fifo Push Offset */
+#define HFI_RFIFO_SIZE 0x0348 /* 4: range from 4K to 8M */
+#define HFI_RFIFO_FSLOT_CNT_REG 0x0350 /* Receive Fifo Free Slot Count */
+#define HFI_RFIFO_FINI_POLARITY 0x0358 /* Receive Fifo Finished Polarity */
+#define HFI_RFIFO_INJ_TH_REG 0x0360 /* Receive Fifo Cache Injection
+ Threshold */
+#define HFI_RFIFO_OUT_TH_REG 0x0368 /* Receive Fifo Out-of-Order
+ Threshold */
+#define HFI_RFIFO_OUT_EVENT_REG 0x03C0 /* Receive Fifo Out-of-Order Event
+ Control */
+#define HFI_RFIFO_INTR_REG 0x03C8 /* Receive Fifo Intr Control */
+
+/* Receive Interrupts */
+#define HFI_RINTR_CONTROL_REG 0x03E0 /* Receive Force Intr Control */
+#define HFI_RINTR_STATUS_REG 0x03E8 /* Receivce Intr Status */
+
+/* IP 2K Free Space Descriptor Fifo */
+#define HFI_IP2K_INC_AVAIL_REG 0x0410 /* IP 2k FSD Fifo Inc Avail Slot
+ Count */
+#define HFI_IP2K_BASE_ADDR 0x0420 /* IP 2k FSD Fifo Effective Address */
+#define HFI_IP2K_LKEY 0x0428 /* IP 2k FSD Fifo Local Key */
+#define HFI_IP2K_PULL_REG 0x0440 /* IP 2k FSD Fifo Pull Offset */
+#define HFI_IP2K_SIZE 0x0448 /* IP 2k FSD Fifo Size */
+#define HFI_IP2K_ASLOT_CNT_REG 0x0450 /* IP 2k FSD Fifo Avail Slot Count */
+
+/* RDMA Pending Fifo */
+#define HFI_RDMAP_BASE_ADDR 0x0520 /* RDMA Pending Fifo Efective Address */
+#define HFI_RDMAP_LKEY 0x0528 /* RDMA Pending Fifo Local Key */
+#define HFI_RDMAP_PULL_REG 0x0540 /* RDMA Pending Fifo Pull Offset */
+#define HFI_RDMAP_SIZE 0x0548 /* RDMA Pending Fifo Size */
+#define HFI_RDMAP_READ_TH_REG 0x0568 /* RDMA Pending Fifo Read Request
+ Threshold */
+#define HFI_RDMAP_PUSH_REG 0x0570 /* RDMA Pending Fifo Push Offset */
+#define HFI_RDMAP_PEND_REG 0x0550 /* RDMA Pending Fifo Pending Count */
+
+/* Send Special Fifo */
+#define HFI_SSFIFO_BASE_ADDR 0x0620 /* Send Special Fifo Effective
+ Address */
+#define HFI_SSFIFO_LKEY 0x0628 /* Send Special Fifo Local Key */
+#define HFI_SSFIFO_PULL_REG 0x0640 /* Send Special Fifo Pull Offset */
+#define HFI_SSFIFO_SIZE 0x0648 /* Send Special Fifo Size */
+#define HFI_SSFIFO_PUSH_REG 0x0670 /* Send Special Fifo Push Offset */
+#define HFI_SSFIFO_PENG_REG 0x0650 /* Send Special Fifo Pending Count */
+
+/* IP Context */
+#define HFI_IP_MCAST_ENABLE_REG 0x0820 /* IP Send - Multi-cast Enable */
+#define HFI_IP_DISABLE_ISR_REG 0x0828 /* IP Send - Disable Src_ISR_ID
+ Stamp */
+#define HFI_IP_PORT_VALID_REG 0x0830 /* IP Logical Port ID Valid */
+#define HFI_IP_PORT_REG 0x0838 /* IP Logical Port ID */
+#define HFI_IP_RECV_SIZE 0x0860 /* IP Recv with Payload Max Size */
+#define HFI_IP_RCV_IMM_REG 0x0868 /* IP RCV-Immediate Max Size */
+
+/* RDMA Context */
+#define HFI_RDMA_RCXT_BASE_ADDR 0x0920 /* RDMA Rcv RCxt Effective Address */
+#define HFI_RDMA_RCXT_LKEY 0x0928 /* RDMA RCxt Local Key */
+#define HFI_RDMA_RCXT_PAY_LKEY 0x0058 /* RDMA Payload Local Key
+ (no-sequential) */
+#define HFI_RDMA_RCXT_EPOCH 0x0980 /* RCxt Update Epoch */
+#define HFI_RDMA_RCXT_CACHE 0x0990 /* RCxt Cache Entry Flush Request */
+
+/* Counters */
+#define HFI_PACKETS_SENT_REG 0x0C00 /* Packets Sent */
+#define HFI_PSENT_DROP_REG 0x0C08 /* Packets Dropped from Sending */
+#define HFI_PIND_SENT_CNT_REG 0x0C10 /* Packet-Indicated Send Count */
+#define HFI_IMM_SEND_CNT_REG 0x0C18 /* Immed Send Packet Count */
+#define HFI_PACKETS_RCV_REG 0x0C40 /* Packets Received */
+#define HFI_PRCV_DROP_REG 0x0C48 /* Packets Dropped from Receiving */
+#define HFI_PIND_RCV_CNT_REG 0x0C50 /* Packet-Indicated Receive Count */
+#define HFI_SBIT_EEC_CNT_REG 0x0C60 /* Single-Bit ECC Count */
+#define HFI_SBIT_EEC_TH_REG 0x0C68 /* Single-Bit ECC Threshold for Error */
+#define HFI_ADDR_XLAT_CNT_REG 0x0C80 /* Addr Xlat Wait Count */
+
+/* Misc Non-Window Registers */
+#define HFI_NUM_WINDOWS_REG 0x0000 /* Number of Windows */
+#define HFI_AGGR_PSENT_CNT_REG 0x0100 /* Aggregate Packet Sent Count */
+#define HFI_AGGR_PSENT_DROP_REG 0x0108 /* Aggregate Packet Dropped from
+ Sending Count */
+#define HFI_AGGR_PRCV_CNT_REG 0x0110 /* Aggregate Packet Receive Count */
+#define HFI_AGGR_PRCV_DROP_REG 0x0118 /* Aggregate Packet Dropped from
+ Receive Count */
+#define HFI_AGGR_ISEND_CNT_REG 0x0120 /* Aggregate Immediate Send Packet
+ Sent Count */
+#define HFI_AGGR_SR_CNT_REG 0x0128 /* Aggregate Send/Rcv Packet Send
+ Count */
+#define HFI_AGGR_FRDMA_CNT_REG 0x0130 /* Aggregate Full-RDMA Packet Sent
+ Count */
+#define HFI_AGGR_HRDMA_CNT_REG 0x0138 /* Aggregate Half-RDMA Packet Sent
+ Count */
+#define HFI_AGGR_SRDMA_CNT_REG 0x0140 /* Aggregate Small-RDMA Packet Sent
+ Count */
+#define HFI_AGGR_IP_CNT_REG 0x0148 /* Aggregate IP Packet Sent Count */
+#define HFI_AGGR_CAU_CNT_REG 0x0150 /* Aggregate CAU Packet Sent Count */
+#define HFI_AGGR_GUPS_CNT_REG 0x0158 /* Aggregate GUPS Packet Sent Count */
+#define HFI_AGGR_NOTIFS_CNT_REG 0x0170 /* Aggregate Notifications Packet Sent
+ Count*/
+
+#define HFI_RCXT_FLUSH_REG 0x0600 /* RCxt Cache Window Flush Request */
+#define HFI_PG_MIGR1_REG 0x0708 /* Page Migration Register 1 */
+#define HFI_PG_MIGR2_REG 0x0710 /* Page Migration Register 2 */
+#define HFI_PG_MIGR3_REG 0x0718 /* Page Migration Register 3 */
+#define HFI_PG_MIGR4_REG 0x0720 /* Page Migration Register 4 */
+#define HFI_PG_MIGR5_REG 0x0728 /* Page Migration Register 5 */
+#define HFI_PG_MIGR6_REG 0x0730 /* Page Migration Register 6 */
+#define HFI_PG_MIGR7_REG 0x0738 /* Page Migration Register 7 */
+#define HFI_PG_MIGR1_RESV_REG 0x0808 /* Page Migration Reservation 1 */
+#define HFI_PG_MIGR2_RESV_REG 0x0810 /* Page Migration Reservation 2 */
+#define HFI_PG_MIGR3_RESV_REG 0x0818 /* Page Migration Reservation 3 */
+#define HFI_PG_MIGR4_RESV_REG 0x0820 /* Page Migration Reservation 4 */
+#define HFI_PG_MIGR5_RESV_REG 0x0828 /* Page Migration Reservation 5 */
+#define HFI_PG_MIGR6_RESV_REG 0x0830 /* Page Migration Reservation 6 */
+#define HFI_PG_MIGR7_RESV_REG 0x0838 /* Page Migration Reservation 7 */
+#define HFI_ADDR_XLAT_WCNT_REG 0x0A20 /* Addr Xlat Wait Count */
+
+#define MASK_56_BITS 0x00ffffffffffffff
+#define MASK_40_BITS 0x000000ffffffffff
+
+#endif /* HFIDD_REGS_H */
--
1.7.3.5
^ permalink raw reply related
* [PATCH v2 03/27] HFI: Add device_create/device_destroy calls for HFI devices.
From: dykmanj @ 2011-04-18 3:21 UTC (permalink / raw)
To: netdev
Cc: Jim Dykman, Piyush Chaudhary, Fu-Chung Chang, William S. Cadden,
Wen C. Chen, Scot Sakolish, Jian Xiao, Carol L. Soto,
Sarah J. Sheppard
In-Reply-To: <1303096919-7367-1-git-send-email-dykmanj@linux.vnet.ibm.com>
From: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Piyush Chaudhary <piyushc@linux.vnet.ibm.com>
Signed-off-by: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
Signed-off-by: William S. Cadden <wscadden@linux.vnet.ibm.com>
Signed-off-by: Wen C. Chen <winstonc@linux.vnet.ibm.com>
Signed-off-by: Scot Sakolish <sakolish@linux.vnet.ibm.com>
Signed-off-by: Jian Xiao <jian@linux.vnet.ibm.com>
Signed-off-by: Carol L. Soto <clsoto@linux.vnet.ibm.com>
Signed-off-by: Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
---
drivers/net/hfi/core/hfidd_init.c | 52 ++++++++++++++++++++++++++++++++++++
include/linux/hfi/hfidd_internal.h | 1 +
2 files changed, 53 insertions(+), 0 deletions(-)
diff --git a/drivers/net/hfi/core/hfidd_init.c b/drivers/net/hfi/core/hfidd_init.c
index 114b772..1e4898b 100644
--- a/drivers/net/hfi/core/hfidd_init.c
+++ b/drivers/net/hfi/core/hfidd_init.c
@@ -47,6 +47,7 @@ MODULE_LICENSE("GPL v2");
struct hfidd_global hfidd_global;
EXPORT_SYMBOL_GPL(hfidd_global);
+struct device *hfidd_class_dev[MAX_HFIS + 1];
static dev_t hfidd_dev;
#define MAX_HFI_DEVS (MAX_HFIS + 1)
@@ -71,6 +72,38 @@ static const struct file_operations hfidd_fops = {
.write = hfidd_cmd_write,
};
+/* Create the hfi device */
+static int hfidd_mkdev(int ai, struct hfidd_acs *p_acs)
+{
+ char dname[128];
+ int rc = 0;
+
+ sprintf(dname, "%s%d", HFIDD_DEV_NAME, ai);
+
+ hfidd_class_dev[ai] = device_create(hfidd_global.class,
+ NULL, MKDEV(MAJOR(hfidd_dev), ai),
+ (void *)p_acs, (char *)dname);
+
+ if (IS_ERR(hfidd_class_dev[ai])) {
+ rc = PTR_ERR(hfidd_class_dev[ai]);
+ printk(KERN_ERR "%s: hfidd_mkdev: device_create for ai=%d fail"
+ " rc = %d\n", dname, ai, rc);
+ return rc;
+ }
+
+ if (ai == MAX_HFIS)
+ return 0;
+
+ p_acs->hfidd_dev = hfidd_class_dev[ai];
+ return rc;
+}
+
+/* delete the hfi device, /dev/hfi* files and sysclass files */
+static void hfidd_rmdev(int ai)
+{
+ device_destroy(hfidd_global.class, MKDEV(MAJOR(hfidd_dev), ai));
+}
+
/* Destroy the HFI class */
static inline void hfidd_destroy_class(void)
{
@@ -129,6 +162,8 @@ static void hfidd_destroy_devices(void)
hfidd_global.p_acs[i] = NULL;
hfidd_global.acs_cnt--;
}
+ for (i = 0; i <= MAX_HFIS; i++)
+ hfidd_rmdev(i);
}
/*
@@ -156,6 +191,23 @@ static int hfidd_create_devices(void)
}
hfidd_global.acs_cnt++;
}
+
+ for (i = 0; i <= MAX_HFIS; i++) {
+ rc = hfidd_mkdev(i, hfidd_global.p_acs[i]);
+ if (rc) {
+ for (j = 0; j < i; j++)
+ hfidd_rmdev(j);
+ goto hfidd_create_devices_error0;
+ }
+ }
+ return 0;
+
+hfidd_create_devices_error0:
+ for (i = 0; i < MAX_HFIS; i++) {
+ hfidd_free_adapter(hfidd_global.p_acs[i]);
+ hfidd_global.p_acs[i] = NULL;
+ hfidd_global.acs_cnt--;
+ }
return rc;
}
diff --git a/include/linux/hfi/hfidd_internal.h b/include/linux/hfi/hfidd_internal.h
index 2c58b56..695d7f4 100644
--- a/include/linux/hfi/hfidd_internal.h
+++ b/include/linux/hfi/hfidd_internal.h
@@ -54,6 +54,7 @@ struct hfidd_acs {
unsigned int index;
unsigned int acs_cnt;
unsigned int state;
+ struct device *hfidd_dev;
};
/* DD global */
--
1.7.3.5
^ permalink raw reply related
* [PATCH v2 16/27] HFI: Add window open hypervisor call
From: dykmanj @ 2011-04-18 3:21 UTC (permalink / raw)
To: netdev
Cc: Jim Dykman, Piyush Chaudhary, Fu-Chung Chang, William S. Cadden,
Wen C. Chen, Scot Sakolish, Jian Xiao, Carol L. Soto,
Sarah J. Sheppard
In-Reply-To: <1303096919-7367-1-git-send-email-dykmanj@linux.vnet.ibm.com>
From: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Piyush Chaudhary <piyushc@linux.vnet.ibm.com>
Signed-off-by: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
Signed-off-by: William S. Cadden <wscadden@linux.vnet.ibm.com>
Signed-off-by: Wen C. Chen <winstonc@linux.vnet.ibm.com>
Signed-off-by: Scot Sakolish <sakolish@linux.vnet.ibm.com>
Signed-off-by: Jian Xiao <jian@linux.vnet.ibm.com>
Signed-off-by: Carol L. Soto <clsoto@linux.vnet.ibm.com>
Signed-off-by: Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
---
drivers/net/hfi/core/hfidd_hcalls.c | 50 +++++++++++++++++++++++++
drivers/net/hfi/core/hfidd_proto.h | 6 +++
include/linux/hfi/hfidd_hcalls.h | 69 +++++++++++++++++++++++++++++++++++
3 files changed, 125 insertions(+), 0 deletions(-)
diff --git a/drivers/net/hfi/core/hfidd_hcalls.c b/drivers/net/hfi/core/hfidd_hcalls.c
index aabb2a8..1915336 100644
--- a/drivers/net/hfi/core/hfidd_hcalls.c
+++ b/drivers/net/hfi/core/hfidd_hcalls.c
@@ -131,6 +131,28 @@ static inline long long h_hfi_query_interface(int token,
return rc;
}
+static inline long long h_hfi_open_window(int token,
+ u64 HFI_chip_ID,
+ u64 win_num,
+ u64 flag,
+ u64 win_info_ptr,
+ u64 *user_mmio,
+ u64 *kernel_mmio,
+ u64 *send_int_num,
+ u64 *recv_int_num)
+{
+ long long rc;
+ u64 hyp_outputs[PLPAR_HCALL_BUFSIZE];
+
+ rc = plpar_hcall(token, (unsigned long *)hyp_outputs, HFI_chip_ID,
+ win_num, flag, win_info_ptr);
+ *user_mmio = hyp_outputs[0]; /* 1st ret value */
+ *kernel_mmio = hyp_outputs[1]; /* 2nd */
+ *send_int_num = hyp_outputs[2]; /* 3rd */
+ *recv_int_num = hyp_outputs[3]; /* 4th */
+ return rc;
+}
+
long long hfi_start_nmmu(u64 chip_id, void *nmmu_info)
{
return h_nmmu_start(H_NMMU_START, chip_id, nmmu_info);
@@ -152,6 +174,34 @@ long long hfi_stop_nmmu(u64 chip_id)
return hvrc;
}
+long long hfi_open_window(u64 unit_id, u64 win_id, u64 flag,
+ u64 win_info_p,
+ u64 *ummio_addr_p,
+ u64 *pmmio_addr_p,
+ u64 *send_intr,
+ u64 *recv_intr)
+{
+ long long hvrc;
+ u64 start_time = get_jiffies_64();
+
+ while (1) {
+ hvrc = h_hfi_open_window(H_HFI_OPEN_WINDOW,
+ unit_id,
+ win_id,
+ flag,
+ win_info_p,
+ ummio_addr_p,
+ pmmio_addr_p,
+ send_intr,
+ recv_intr);
+ if (hvrc != H_BUSY)
+ break;
+ if (hfidd_age_hcall(start_time))
+ break;
+ }
+ return hvrc;
+}
+
long long hfi_allocate_mr(u64 chip_id, u64 res, u64 addr, u64 mr_size,
u64 access,
u64 job_id,
diff --git a/drivers/net/hfi/core/hfidd_proto.h b/drivers/net/hfi/core/hfidd_proto.h
index ff39a02..c4ed215 100644
--- a/drivers/net/hfi/core/hfidd_proto.h
+++ b/drivers/net/hfi/core/hfidd_proto.h
@@ -67,6 +67,12 @@ int hfidd_start_interface(struct hfidd_acs *p_acs);
int hfidd_stop_interface(struct hfidd_acs *p_acs, unsigned int hfi_id);
long long hfi_start_nmmu(u64 chip_id, void *nmmu_info);
long long hfi_stop_nmmu(u64 chip_id);
+long long hfi_open_window(u64 unit_id, u64 win_id, u64 flag,
+ u64 win_info_p,
+ u64 *ummio_addr_p,
+ u64 *pmmio_addr_p,
+ u64 *send_intr,
+ u64 *recv_intr);
long long hfi_allocate_mr(u64 chip_id, u64 res, u64 addr,
u64 mr_size,
u64 access,
diff --git a/include/linux/hfi/hfidd_hcalls.h b/include/linux/hfi/hfidd_hcalls.h
index 3c9f556..a97bb5e 100644
--- a/include/linux/hfi/hfidd_hcalls.h
+++ b/include/linux/hfi/hfidd_hcalls.h
@@ -39,12 +39,19 @@
#define H_HFI_START_INTERFACE 0xF000
#define H_HFI_QUERY_INTERFACE 0xF004
#define H_HFI_STOP_INTERFACE 0xF008
+#define H_HFI_OPEN_WINDOW 0xF00C
#define H_NMMU_START 0xF028
#define H_NMMU_STOP 0xF02C
#define H_NMMU_ALLOCATE_RESOURCE 0xF030
#define H_NMMU_FREE_RESOURCE 0xF034
#define H_NMMU_MODIFY_RESOURCE 0xF03C
+#define H_OPEN 0x8000000000000000
+#define H_RESUME 0x0000000000000000
+#define H_SUSPEND 0x0000000000000000
+#define H_CLOSE 0x0000000000000001
+#define H_CHECK_CLOSED 0x0000000000000002
+
#define NMMU_MR 0
#define NMMU_MAP 1
@@ -63,6 +70,68 @@
#define HFI_ACCESS_CTL_SHIFT 32
+struct win_open_info {
+ /* Hyp Feedback */
+ unsigned long long hypervisor_capabilities;
+ unsigned int error_offset;
+
+ /* Window Control */
+ unsigned int job_id; /* send & recv jobid */
+ unsigned int protection_domain;
+
+ /* Immediate Send Context */
+ unsigned int immediate_send_pid;
+ unsigned int immediate_send_slots;
+ unsigned int immediate_send_update_freq;
+ unsigned long long immediate_send_finish_vec;
+
+ /* Send Fifo */
+ unsigned long long sfifo_base_eaddr;
+ unsigned int sfifo_lkey;
+ unsigned int sfifo_size; /* in bytes */
+ unsigned long long sfifo_finish_vec;
+
+ /* Full RDMA Send Fifo */
+ unsigned long long fullrdma_fifo_base_eaddr;
+ unsigned int fullrdma_fifo_lkey;
+ unsigned int fullrdma_fifo_size; /* in bytes */
+ unsigned int fullrdma_msg_breakup_count;
+ unsigned long long fullrdma_fifo_finish_vec;
+
+ /* Receive Fifo */
+ unsigned long long rfifo_base_eaddr;
+ unsigned int rfifo_lkey;
+ unsigned int rfifo_size; /* in bytes */
+
+ /* IP2k Free Space Decriptor Fifo */
+ unsigned long long ip2kfifo_base_eaddr;
+ unsigned int ip2kfifo_lkey;
+ unsigned int ip2kfifo_size; /* in bytes */
+
+ /* RDMA Pending Fifo */
+ unsigned long long rdmapending_base_eaddr;
+ unsigned int rdmapending_lkey;
+ unsigned int rdmapending_size; /* in bytes */
+ unsigned int rdmapending_read_req_thresh;
+
+ /* SendSpecial Fifo */
+ unsigned long long specialfifo_base_eaddr;
+ unsigned int specialfifo_lkey;
+ unsigned int specialfifo_size; /* in bytes */
+
+ /* IP Context */
+ unsigned int is_ip_window;
+ unsigned int multicast_enable;
+ unsigned int disable_src_isr_id_stamp;
+ unsigned int logical_port_id_valid;
+ unsigned int logical_port_id;
+
+ /* RDMA Context */
+ unsigned long long rcxt_base_eaddr;
+ unsigned int rcxt_lkey;
+ unsigned int rdma_payload_lkey;
+};
+
#define EEH_QUERY 1
#define COMP_QUERY 2
--
1.7.3.5
^ permalink raw reply related
* [PATCH v2 21/27] HFI: Add send and receive interrupts
From: dykmanj @ 2011-04-18 3:21 UTC (permalink / raw)
To: netdev
Cc: Jim Dykman, Piyush Chaudhary, Fu-Chung Chang, William S. Cadden,
Wen C. Chen, Scot Sakolish, Jian Xiao, Carol L. Soto,
Sarah J. Sheppard
In-Reply-To: <1303096919-7367-1-git-send-email-dykmanj@linux.vnet.ibm.com>
From: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Each window has its own interrupt for send interrupts and another for receive
interrupts.
Signed-off-by: Piyush Chaudhary <piyushc@linux.vnet.ibm.com>
Signed-off-by: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
Signed-off-by: William S. Cadden <wscadden@linux.vnet.ibm.com>
Signed-off-by: Wen C. Chen <winstonc@linux.vnet.ibm.com>
Signed-off-by: Scot Sakolish <sakolish@linux.vnet.ibm.com>
Signed-off-by: Jian Xiao <jian@linux.vnet.ibm.com>
Signed-off-by: Carol L. Soto <clsoto@linux.vnet.ibm.com>
Signed-off-by: Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
---
drivers/net/hfi/core/Makefile | 1 +
drivers/net/hfi/core/hfidd_intr.c | 127 +++++++++++++++++++++++++++++++++++
drivers/net/hfi/core/hfidd_proto.h | 3 +
drivers/net/hfi/core/hfidd_window.c | 16 ++++-
include/linux/hfi/hfidd_client.h | 17 +++++
include/linux/hfi/hfidd_internal.h | 2 +
6 files changed, 165 insertions(+), 1 deletions(-)
create mode 100644 drivers/net/hfi/core/hfidd_intr.c
diff --git a/drivers/net/hfi/core/Makefile b/drivers/net/hfi/core/Makefile
index 3adf07e..d2ed86f 100644
--- a/drivers/net/hfi/core/Makefile
+++ b/drivers/net/hfi/core/Makefile
@@ -6,5 +6,6 @@ hfi_core-objs:= hfidd_adpt.o \
hfidd_init.o \
hfidd_xlat.o \
hfidd_map.o \
+ hfidd_intr.o \
hfidd_hcalls.o
obj-$(CONFIG_HFI) += hfi_core.o
diff --git a/drivers/net/hfi/core/hfidd_intr.c b/drivers/net/hfi/core/hfidd_intr.c
new file mode 100644
index 0000000..253de27
--- /dev/null
+++ b/drivers/net/hfi/core/hfidd_intr.c
@@ -0,0 +1,127 @@
+/*
+ * hfidd_intr.c
+ *
+ * HFI device driver for IBM System p
+ *
+ * Authors:
+ * Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
+ * William S. Cadden <wscadden@linux.vnet.ibm.com>
+ * Wen C. Chen <winstonc@linux.vnet.ibm.com>
+ * Scot Sakolish <sakolish@linux.vnet.ibm.com>
+ * Jian Xiao <jian@linux.vnet.ibm.com>
+ * Carol L. Soto <clsoto@linux.vnet.ibm.com>
+ * Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
+ *
+ * (C) Copyright IBM Corp. 2010
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include <linux/hfi/hfidd_internal.h>
+#include "hfidd_proto.h"
+
+static irqreturn_t send_intr_handler(int irq, void *data)
+{
+ struct hfidd_window *win_p = data;
+ struct hfidd_acs *p_acs;
+
+ p_acs = hfidd_global.p_acs[win_p->ai];
+ if (p_acs == NULL)
+ return IRQ_HANDLED;
+
+ return IRQ_HANDLED;
+}
+
+static irqreturn_t recv_intr_handler(int irq, void *data)
+{
+ struct hfidd_window *win_p = data;
+ struct hfidd_acs *p_acs;
+
+ p_acs = hfidd_global.p_acs[win_p->ai];
+ if (p_acs == NULL)
+ return IRQ_HANDLED;
+
+ return IRQ_HANDLED;
+}
+
+static inline void hfidd_clear_interrupt(unsigned int int_level,
+ struct hfidd_window *win_p)
+{
+ ibmebus_free_irq(int_level, win_p);
+}
+
+static int hfidd_init_interrupt(struct hfidd_acs *p_acs,
+ struct hfidd_window *win_p ,
+ irqreturn_t (*handler)(int, void *),
+ const char *name,
+ unsigned int int_level)
+{
+ int rc;
+
+ rc = ibmebus_request_irq(int_level, handler, IRQF_DISABLED, name,
+ win_p);
+ if (rc != 0) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_init_interrupt: request_irq failed for "
+ "int_level 0x%x rc %d\n", int_level, rc);
+ return rc;
+ }
+ return rc;
+}
+
+int hfidd_init_win_interrupt(struct hfidd_acs *p_acs,
+ struct hfidd_window *win_p)
+{
+ int rc;
+
+ /* init send interrupt handler */
+ snprintf(win_p->send_name, IRQ_NAME_SIZE - 1, "%s%d-send%d",
+ HFIDD_DEV_NAME, p_acs->index, win_p->index);
+ rc = hfidd_init_interrupt(p_acs, win_p, send_intr_handler,
+ win_p->send_name, win_p->send_intr);
+ if (rc != 0) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_init_win_interrupt: send int failed, "
+ "rc = 0x%x\n", rc);
+ return rc;
+ }
+
+ /* init recv interrupt handler */
+ snprintf(win_p->recv_name, IRQ_NAME_SIZE - 1, "%s%d-recv%d",
+ HFIDD_DEV_NAME, p_acs->index, win_p->index);
+ rc = hfidd_init_interrupt(p_acs, win_p, recv_intr_handler,
+ win_p->recv_name, win_p->recv_intr);
+ if (rc != 0) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_init_win_interrupt: recv int failed, "
+ "rc = 0x%x\n", rc);
+ hfidd_clear_interrupt(win_p->send_intr, win_p);
+ return rc;
+ }
+ return 0;
+}
+
+void hfidd_clear_win_interrupt(struct hfidd_window *win_p)
+{
+ if (win_p->send_intr != 0) {
+ hfidd_clear_interrupt(win_p->send_intr, win_p);
+ win_p->send_intr = 0;
+ }
+ if (win_p->recv_intr != 0) {
+ hfidd_clear_interrupt(win_p->recv_intr, win_p);
+ win_p->recv_intr = 0;
+ }
+}
diff --git a/drivers/net/hfi/core/hfidd_proto.h b/drivers/net/hfi/core/hfidd_proto.h
index f531dcd..af88f0b 100644
--- a/drivers/net/hfi/core/hfidd_proto.h
+++ b/drivers/net/hfi/core/hfidd_proto.h
@@ -73,6 +73,9 @@ int hfidd_query_interface(struct hfidd_acs *p_acs, unsigned int subtype,
int hfidd_start_nmmu(struct hfidd_acs *p_acs);
int hfidd_start_interface(struct hfidd_acs *p_acs);
int hfidd_stop_interface(struct hfidd_acs *p_acs, unsigned int hfi_id);
+int hfidd_init_win_interrupt(struct hfidd_acs *p_acs,
+ struct hfidd_window *win_p);
+void hfidd_clear_win_interrupt(struct hfidd_window *win_p);
long long hfi_start_nmmu(u64 chip_id, void *nmmu_info);
long long hfi_stop_nmmu(u64 chip_id);
long long hfi_open_window(u64 unit_id, u64 win_id, u64 flag,
diff --git a/drivers/net/hfi/core/hfidd_window.c b/drivers/net/hfi/core/hfidd_window.c
index fd692eb..6864eae 100644
--- a/drivers/net/hfi/core/hfidd_window.c
+++ b/drivers/net/hfi/core/hfidd_window.c
@@ -1049,6 +1049,15 @@ int hfidd_open_window_func(struct hfidd_acs *p_acs, unsigned int is_userspace,
local_p->local_isrid = p_acs->isr;
win_p->client_info.local_isrid = p_acs->isr;
+ /* Init the send and recv interrupt handlers */
+ rc = hfidd_init_win_interrupt(p_acs, win_p);
+ if (rc) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_open_window_func: hfidd_init_win_interrupt "
+ "failed, rc = 0x%x\n", rc);
+ goto hfidd_open_window_func_err6;
+ }
+
/* Copy out the client info back to user */
rc = hfi_copy_to_user((void *)out_p, (void *)local_p,
is_userspace, sizeof(struct hfi_client_info));
@@ -1056,7 +1065,7 @@ int hfidd_open_window_func(struct hfidd_acs *p_acs, unsigned int is_userspace,
dev_printk(KERN_ERR, p_acs->hfidd_dev,
"hfidd_open_window_func: hfi_copy_to_user "
"failed, rc = 0x%x\n", rc);
- goto hfidd_open_window_func_err6;
+ goto hfidd_open_window_func_err7;
}
spin_lock(&(win_p->win_lock));
@@ -1068,6 +1077,8 @@ int hfidd_open_window_func(struct hfidd_acs *p_acs, unsigned int is_userspace,
kfree(local_p);
return rc;
+hfidd_open_window_func_err7:
+ hfidd_clear_win_interrupt(win_p);
hfidd_open_window_func_err6:
if (is_userspace)
hfidd_unmap(local_p->mmio_regs.use.kptr, PAGE_SIZE_64K);
@@ -1134,6 +1145,9 @@ int hfidd_close_window_internal(struct hfidd_acs *p_acs,
}
spin_unlock(&(win_p->win_lock));
+ /* Clear the send and recv interrupt handlers */
+ hfidd_clear_win_interrupt(win_p);
+
rc = hfi_unmap_mmio_regs(p_acs, win_p, is_userspace);
if (rc) {
dev_printk(KERN_ERR, p_acs->hfidd_dev,
diff --git a/include/linux/hfi/hfidd_client.h b/include/linux/hfi/hfidd_client.h
index 11c8973..3b2d032 100644
--- a/include/linux/hfi/hfidd_client.h
+++ b/include/linux/hfi/hfidd_client.h
@@ -121,6 +121,23 @@ struct hfi_window_info {
unsigned int window;
};
+/* Event Notification */
+enum hfi_event_type {
+ HFIDD_SEND = 0,
+ HFIDD_RECV = 1,
+ HFIDD_WIN_ERROR = 2,
+ HFIDD_HFI_ERROR = 3,
+ HFIDD_TERMINATE = 4,
+ HFIDD_RELEASE_WINDOW = 5,
+ HFIDD_CAU_ERROR = 6,
+ HFIDD_ICS_ERROR = 7,
+ HFIDD_HFI_READY_REG = 8,
+ HFIDD_ROUTE_CHANGE = 9,
+ HFIDD_IP_TRC_LVL = 10, /* IP Window only */
+ HFIDD_POOL_SIZE = 11, /* IP Window only */
+ HFIDD_NUM_EVENT_TYPES = 12
+};
+
#define MAX_TORRENTS 1
#define MAX_HFI_PER_TORRENT 2
#define MAX_HFIS (MAX_TORRENTS * MAX_HFI_PER_TORRENT)
diff --git a/include/linux/hfi/hfidd_internal.h b/include/linux/hfi/hfidd_internal.h
index 0d6b77b..e96142a 100644
--- a/include/linux/hfi/hfidd_internal.h
+++ b/include/linux/hfi/hfidd_internal.h
@@ -145,6 +145,8 @@ struct hfidd_global {
struct hfidd_acs *p_acs[MAX_HFIS];
};
+extern struct hfidd_global hfidd_global;
+
static inline struct hfidd_window *hfi_window(struct hfidd_acs *p,
unsigned int idx)
{
--
1.7.3.5
^ permalink raw reply related
* [PATCH v2 18/27] HFI: Map window registers into user process
From: dykmanj @ 2011-04-18 3:21 UTC (permalink / raw)
To: netdev
Cc: Jim Dykman, Piyush Chaudhary, Fu-Chung Chang, William S. Cadden,
Wen C. Chen, Scot Sakolish, Jian Xiao, Carol L. Soto,
Sarah J. Sheppard
In-Reply-To: <1303096919-7367-1-git-send-email-dykmanj@linux.vnet.ibm.com>
From: Jim Dykman <dykmanj@linux.vnet.ibm.com>
User-space applications send and receive without kernel involvement, once
the window is open. A page of hardware registers controlling the appropriate
window is mapped into the user's address space.
Signed-off-by: Piyush Chaudhary <piyushc@linux.vnet.ibm.com>
Signed-off-by: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
Signed-off-by: William S. Cadden <wscadden@linux.vnet.ibm.com>
Signed-off-by: Wen C. Chen <winstonc@linux.vnet.ibm.com>
Signed-off-by: Scot Sakolish <sakolish@linux.vnet.ibm.com>
Signed-off-by: Jian Xiao <jian@linux.vnet.ibm.com>
Signed-off-by: Carol L. Soto <clsoto@linux.vnet.ibm.com>
Signed-off-by: Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
---
drivers/net/hfi/core/Makefile | 1 +
drivers/net/hfi/core/hfidd_map.c | 99 +++++++++++++++++++++++++++++++++++
drivers/net/hfi/core/hfidd_proto.h | 4 ++
drivers/net/hfi/core/hfidd_window.c | 51 ++++++++++++++++++-
4 files changed, 154 insertions(+), 1 deletions(-)
create mode 100644 drivers/net/hfi/core/hfidd_map.c
diff --git a/drivers/net/hfi/core/Makefile b/drivers/net/hfi/core/Makefile
index 8d5558d..3adf07e 100644
--- a/drivers/net/hfi/core/Makefile
+++ b/drivers/net/hfi/core/Makefile
@@ -5,5 +5,6 @@ hfi_core-objs:= hfidd_adpt.o \
hfidd_window.o \
hfidd_init.o \
hfidd_xlat.o \
+ hfidd_map.o \
hfidd_hcalls.o
obj-$(CONFIG_HFI) += hfi_core.o
diff --git a/drivers/net/hfi/core/hfidd_map.c b/drivers/net/hfi/core/hfidd_map.c
new file mode 100644
index 0000000..816e7ae
--- /dev/null
+++ b/drivers/net/hfi/core/hfidd_map.c
@@ -0,0 +1,99 @@
+/*
+ * hfidd_map.c
+ *
+ * HFI device driver for IBM System p
+ *
+ * Authors:
+ * Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
+ * William S. Cadden <wscadden@linux.vnet.ibm.com>
+ * Wen C. Chen <winstonc@linux.vnet.ibm.com>
+ * Scot Sakolish <sakolish@linux.vnet.ibm.com>
+ * Jian Xiao <jian@linux.vnet.ibm.com>
+ * Carol L. Soto <clsoto@linux.vnet.ibm.com>
+ * Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
+ *
+ * (C) Copyright IBM Corp. 2010
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include <linux/io.h>
+#include <linux/hfi/hfidd_internal.h>
+
+int hfidd_mmap(struct hfidd_acs *p_acs, void **eaddr, int size,
+ unsigned long vm_flag, unsigned long long busaddr,
+ unsigned long long offset)
+{
+ struct vm_area_struct *vma;
+ unsigned long vsize;
+ int rc;
+
+ down_write(¤t->mm->mmap_sem);
+ *eaddr = (void *)do_mmap(NULL, (unsigned long)*eaddr, size, PROT_WRITE,
+ MAP_SHARED | MAP_ANONYMOUS,
+ offset);
+ up_write(¤t->mm->mmap_sem);
+ if (*eaddr) {
+ vma = find_vma(current->mm, (u64) *eaddr);
+ if (!vma) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_mmap: find_vma failed\n");
+ return -ENOMEM;
+ }
+ } else {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_mmap: do_mmap failed\n");
+ return -ENOMEM;
+ }
+
+ vsize = vma->vm_end - vma->vm_start;
+ if (vsize != size) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_mmap: Wrong sizes: vsize = %ld "
+ "size = %d\n", vsize, size);
+ return -EINVAL;
+ }
+
+ if (vm_flag == VM_RESERVED)
+ vma->vm_page_prot = pgprot_val(vma->vm_page_prot);
+ else
+ vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+ vma->vm_flags |= vm_flag;
+
+ rc = remap_pfn_range(vma, vma->vm_start, busaddr >> PAGE_SHIFT, size,
+ vma->vm_page_prot);
+ if (rc) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_mmap: remap_pfn_range failed\n");
+ return -ENOMEM;
+ }
+
+ return 0;
+}
+
+int hfidd_unmap(void *addr, int size)
+{
+ int rc = 0;
+ struct mm_struct *mm = current->mm;
+
+ if (mm && (addr != NULL)) {
+ down_write(&mm->mmap_sem);
+ rc = do_munmap(mm, (unsigned long)addr, size);
+ up_write(&mm->mmap_sem);
+ }
+
+ return rc;
+}
diff --git a/drivers/net/hfi/core/hfidd_proto.h b/drivers/net/hfi/core/hfidd_proto.h
index c4ed215..1f7fe80 100644
--- a/drivers/net/hfi/core/hfidd_proto.h
+++ b/drivers/net/hfi/core/hfidd_proto.h
@@ -57,6 +57,10 @@ int hfidd_open_window_func(struct hfidd_acs *p_acs, unsigned int is_userspace,
int hfi_register_rpages(struct hfidd_acs *p_acs, unsigned long long mr_handle,
unsigned int submr, struct hfidd_vlxmem *xtab_p,
unsigned int *mapped_pages);
+int hfidd_mmap(struct hfidd_acs *p_acs, void **eaddr, int size,
+ unsigned long vm_flag, unsigned long long busaddr,
+ unsigned long long offset);
+int hfidd_unmap(void *addr, int size);
int hfidd_get_phyp_page(struct hfidd_acs *p_acs, caddr_t *page,
caddr_t *laddr, int size);
void hfidd_release_phyp_page(caddr_t page, int size);
diff --git a/drivers/net/hfi/core/hfidd_window.c b/drivers/net/hfi/core/hfidd_window.c
index c20277b..5d319a1 100644
--- a/drivers/net/hfi/core/hfidd_window.c
+++ b/drivers/net/hfi/core/hfidd_window.c
@@ -874,6 +874,44 @@ setup_window_parm_err1:
return rc;
}
+/* Map the window mmio registers - only user space window */
+static int hfi_map_mmio_regs(struct hfidd_acs *p_acs,
+ unsigned int is_userspace,
+ struct hfidd_window *win_p,
+ struct hfi_client_info *client_p)
+{
+ int rc = 0;
+ unsigned long long offset;
+ void *tmp_eaddr;
+
+ if (!is_userspace) {
+ /* No translation, just pass back the logical address */
+ client_p->mmio_regs.use.kptr = (void *)win_p->mmio_regs;
+ win_p->client_info.mmio_regs.use.kptr =
+ (void *)win_p->mmio_regs;
+ } else {
+ /*
+ * Translate mmio_regs from logical to effective address: 1st
+ * page
+ */
+ tmp_eaddr = 0;
+ offset = (client_p->window) << PAGE_SHIFT_64K;
+ rc = hfidd_mmap(p_acs, &tmp_eaddr, PAGE_SIZE_64K,
+ VM_RESERVED | VM_IO,
+ (long long)win_p->mmio_regs, offset);
+ if (rc) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfi_map_mmio_regs: hfidd_mmap mmio_regs "
+ "failed, rc = 0x%x, mmio_regs = 0x%llx\n",
+ rc, (unsigned long long)win_p->mmio_regs);
+ return rc;
+ }
+ client_p->mmio_regs.use.kptr = tmp_eaddr;
+ win_p->client_info.mmio_regs.use.kptr = tmp_eaddr;
+ }
+ return 0;
+}
+
/*
* Allows an user/kernel window to send/receive network traffic thru HFI
* adapter. This function will allocate the system resources needed to open
@@ -940,6 +978,14 @@ int hfidd_open_window_func(struct hfidd_acs *p_acs, unsigned int is_userspace,
goto hfidd_open_window_func_err4;
}
+ rc = hfi_map_mmio_regs(p_acs, is_userspace, win_p, local_p);
+ if (rc) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_open_window_func: hfi_map_mmio_regs "
+ "failed, rc = 0x%x\n", rc);
+ goto hfidd_open_window_func_err4;
+ }
+
/* tell user the local ISR id */
local_p->local_isrid = p_acs->isr;
win_p->client_info.local_isrid = p_acs->isr;
@@ -951,7 +997,7 @@ int hfidd_open_window_func(struct hfidd_acs *p_acs, unsigned int is_userspace,
dev_printk(KERN_ERR, p_acs->hfidd_dev,
"hfidd_open_window_func: hfi_copy_to_user "
"failed, rc = 0x%x\n", rc);
- goto hfidd_open_window_func_err4;
+ goto hfidd_open_window_func_err5;
}
spin_lock(&(win_p->win_lock));
@@ -963,6 +1009,9 @@ int hfidd_open_window_func(struct hfidd_acs *p_acs, unsigned int is_userspace,
kfree(local_p);
return rc;
+hfidd_open_window_func_err5:
+ if (is_userspace)
+ hfidd_unmap(local_p->mmio_regs.use.kptr, PAGE_SIZE_64K);
hfidd_open_window_func_err4:
hfi_destroy_window_parm(p_acs, is_userspace, win_p, local_p);
hfidd_open_window_func_err3:
--
1.7.3.5
^ permalink raw reply related
* [PATCH v2 08/27] HFI: DD request framework and first HFI DD request
From: dykmanj @ 2011-04-18 3:21 UTC (permalink / raw)
To: netdev
Cc: Jim Dykman, Piyush Chaudhary, Fu-Chung Chang, William S. Cadden,
Wen C. Chen, Scot Sakolish, Jian Xiao, Carol L. Soto,
Sarah J. Sheppard
In-Reply-To: <1303096919-7367-1-git-send-email-dykmanj@linux.vnet.ibm.com>
From: Jim Dykman <dykmanj@linux.vnet.ibm.com>
We use an ioctl-ish mechanism similar to the one found in the HEA driver.
Some of our requests have very large parameter lists, this method allows
us to get the parms into the DD quickly.
Signed-off-by: Piyush Chaudhary <piyushc@linux.vnet.ibm.com>
Signed-off-by: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
Signed-off-by: William S. Cadden <wscadden@linux.vnet.ibm.com>
Signed-off-by: Wen C. Chen <winstonc@linux.vnet.ibm.com>
Signed-off-by: Scot Sakolish <sakolish@linux.vnet.ibm.com>
Signed-off-by: Jian Xiao <jian@linux.vnet.ibm.com>
Signed-off-by: Carol L. Soto <clsoto@linux.vnet.ibm.com>
Signed-off-by: Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
---
drivers/net/hfi/core/hfidd_init.c | 94 +++++++++++++++++++++++++++++++++++-
include/linux/hfi/Kbuild | 1 +
include/linux/hfi/hfidd_client.h | 40 +++++++++++++++
include/linux/hfi/hfidd_internal.h | 23 ++++++++-
include/linux/hfi/hfidd_requests.h | 38 ++++++++++++++
5 files changed, 192 insertions(+), 4 deletions(-)
create mode 100644 include/linux/hfi/hfidd_requests.h
diff --git a/drivers/net/hfi/core/hfidd_init.c b/drivers/net/hfi/core/hfidd_init.c
index cbc616d..ecb6a2f 100644
--- a/drivers/net/hfi/core/hfidd_init.c
+++ b/drivers/net/hfi/core/hfidd_init.c
@@ -37,6 +37,7 @@
#include <linux/of.h>
#include <linux/hfi/hfidd_internal.h>
+#include <linux/hfi/hfidd_requests.h>
#include "hfidd_proto.h"
MODULE_VERSION("1.0");
@@ -60,11 +61,102 @@ static ssize_t hfidd_read(struct file *filep, char *buf, size_t count,
return 0;
}
+/* Query firmare level and use abi version to users */
+static int hfidd_query_dd_info(struct hfidd_acs *p_acs,
+ struct hfi_query_dd_info *user_p)
+{
+ struct hfi_query_dd_info req;
+ int rc;
+
+ req.fw_ec_level = p_acs->dds.fw_ec_level;
+ req.abi_version = HFIDD_USER_ABI_VERSION;
+
+ rc = copy_to_user(user_p, &req, sizeof(struct hfi_query_dd_info));
+ if (rc)
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_query_dd_info: copy_to_user failed\n");
+
+ return rc;
+}
+
/* Entry point for user space to do driver requests. */
static ssize_t hfidd_cmd_write(struct file *filep, const char __user *buf,
size_t count, loff_t *pos)
{
- return 0;
+ struct hfidd_acs *p_acs;
+ int ai;
+ int cnt = 0;
+ int rc = 0;
+ struct hfi_req_hdr cmd;
+ int is_userspace;
+
+ ai = iminor(filep->f_path.dentry->d_inode);
+ if (ai >= MAX_HFIS) {
+ printk(KERN_ERR "%s: hfidd_cmd_write: wrong ai = %d\n",
+ HFIDD_DEV_NAME, ai);
+ return -ENODEV;
+ }
+
+ p_acs = hfidd_global.p_acs[ai];
+ if (p_acs == NULL) {
+ printk(KERN_ERR "%s: hfidd_cmd_write: p_acs is NULL\n",
+ HFIDD_DEV_NAME);
+ return -EINVAL;
+ }
+
+ if (count < sizeof(cmd)) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_cmd_write: Invalid count: 0x%lx expected "
+ "count: 0x%lx\n", count, sizeof(cmd));
+ return -EINVAL;
+ }
+
+ is_userspace = 1;
+ if (segment_eq(get_fs(), KERNEL_DS))
+ is_userspace = 0;
+
+ if (copy_from_user(&cmd, buf, sizeof(cmd))) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_cmd_write: copy_from_user failed\n");
+ return -EINVAL;
+ }
+
+ if (cmd.abi_version != HFIDD_USER_ABI_VERSION) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_cmd_write: wrong abi_version %d, "
+ "should be %d for cmd 0x%x\n",
+ cmd.abi_version, HFIDD_USER_ABI_VERSION, cmd.req);
+ return -EINVAL;
+ }
+
+ switch (cmd.req) {
+ case HFIDD_REQ_QUERY_DD_INFO:
+ if (cmd.req_len != sizeof(struct hfi_query_dd_info)) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_cmd_write: hdr.reqlen 0x%x expected "
+ "0x%x for cmd req 0x%x\n",
+ cmd.req_len, (unsigned int)
+ sizeof(struct hfi_query_dd_info), cmd.req);
+ return -EINVAL;
+ }
+ rc = hfidd_query_dd_info(p_acs, (struct hfi_query_dd_info *)
+ cmd.result.use.kptr);
+ break;
+
+ default:
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_cmd_write: invalid cmd = 0x%x\n", cmd.req);
+ return -EINVAL;
+ }
+
+ if (rc == 0)
+ cnt = count;
+ else
+ cnt = rc;
+
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "hfidd_cmd_write: Exit cmd = 0x%x rc = 0x%x\n", cmd.req, rc);
+ return cnt;
}
static const struct file_operations hfidd_fops = {
diff --git a/include/linux/hfi/Kbuild b/include/linux/hfi/Kbuild
index 3a742ce..6637c65 100644
--- a/include/linux/hfi/Kbuild
+++ b/include/linux/hfi/Kbuild
@@ -1 +1,2 @@
header-y += hfidd_client.h
+header-y += hfidd_requests.h
diff --git a/include/linux/hfi/hfidd_client.h b/include/linux/hfi/hfidd_client.h
index 2714a27..b2ebd01 100644
--- a/include/linux/hfi/hfidd_client.h
+++ b/include/linux/hfi/hfidd_client.h
@@ -33,11 +33,51 @@
#ifndef _HFIDD_CLIENT_H_
#define _HFIDD_CLIENT_H_
+
+#define HFIDD_USER_ABI_VERSION 1
+
+
+/*
+ * New ioctls are not allowed. We will use write() calls to pass
+ * in an ioctl-looking request, with struct hfi_req_hdr giving the
+ * information we used to get from the ioctl() parameter list. The
+ * write() call will copy out the request structure to the buffer pointed
+ * to by result, which is probably the original request.
+ */
+
+struct hfi_64b {
+ union {
+ unsigned long long allu; /* APPLICATION Long long
+ Unsigned 64 bit address
+ container */
+ void *kptr; /* KERNEL Pointer 64 bit
+ container */
+ } use;
+};
+
+/* Request header: first structure in each of the HFI DD requests */
+struct hfi_req_hdr {
+ unsigned int req; /* HFIDD_REQ_* */
+ unsigned int req_len; /* length of req, in bytes */
+ unsigned int abi_version; /* ABI version */
+ struct hfi_64b result; /* user eaddr for output */
+};
+#define HFIDD_REQ_HDR_SIZE sizeof(struct hfi_req_hdr)
+
#define MAX_TORRENTS 1
#define MAX_HFI_PER_TORRENT 2
#define MAX_HFIS (MAX_TORRENTS * MAX_HFI_PER_TORRENT)
#define MAX_WIN_PER_HFI 256
+/*
+ * HFIDD_REQ_QUERY_DD_INFO
+ */
+struct hfi_query_dd_info {
+ struct hfi_req_hdr hdr;
+ unsigned long long fw_ec_level; /* Hardware Version */
+ unsigned int abi_version; /* ABI Version */
+};
+
#define HFI_DYN_WINS_DEFAULT 32
#define PAGE_SIZE_4K 0x1000
diff --git a/include/linux/hfi/hfidd_internal.h b/include/linux/hfi/hfidd_internal.h
index 8fe313d..311f906 100644
--- a/include/linux/hfi/hfidd_internal.h
+++ b/include/linux/hfi/hfidd_internal.h
@@ -36,12 +36,29 @@
#include <linux/fs.h>
#include <linux/kobject.h>
#include <linux/cdev.h>
+#include <linux/compat.h>
+#include <linux/compiler.h>
#include <linux/init.h>
#include <linux/kernel.h>
+#include <linux/mman.h>
+#include <linux/mm.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/poll.h>
#include <linux/slab.h>
-#include <linux/jiffies.h>
-#include <linux/device.h>
-
+#include <linux/vermagic.h>
+#include <linux/delay.h>
+#include <linux/vmalloc.h>
+#include <linux/timer.h>
+#include <linux/spinlock.h>
+#include <linux/sched.h>
+#include <asm/cputable.h>
+#include <linux/io.h>
+#include <asm/machdep.h>
+#include <linux/mmu_context.h>
+#include <asm/pgalloc.h>
+#include <asm/ibmebus.h>
+#include <linux/kthread.h>
#include <linux/hfi/hfidd_client.h>
#include <linux/hfi/hfidd_adpt.h>
#include <linux/hfi/hfidd_hcalls.h>
diff --git a/include/linux/hfi/hfidd_requests.h b/include/linux/hfi/hfidd_requests.h
new file mode 100644
index 0000000..b6e255f
--- /dev/null
+++ b/include/linux/hfi/hfidd_requests.h
@@ -0,0 +1,38 @@
+/*
+ * hfidd_requests.h
+ *
+ * HFI device driver for IBM System p
+ *
+ * Authors:
+ * Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
+ * William S. Cadden <wscadden@linux.vnet.ibm.com>
+ * Wen C. Chen <winstonc@linux.vnet.ibm.com>
+ * Scot Sakolish <sakolish@linux.vnet.ibm.com>
+ * Jian Xiao <jian@linux.vnet.ibm.com>
+ * Carol L. Soto <clsoto@linux.vnet.ibm.com>
+ * Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
+ *
+ * (C) Copyright IBM Corp. 2010
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#ifndef _HFIDD_REQUESTS_H_
+#define _HFIDD_REQUESTS_H_
+
+#define HFIDD_REQ_QUERY_DD_INFO 0x00001004
+
+#endif /* _HFIDD_REQUESTS_H_ */
--
1.7.3.5
^ permalink raw reply related
* [PATCH v2 05/27] HFI: The first few HFI-specific hypervisor calls
From: dykmanj @ 2011-04-18 3:21 UTC (permalink / raw)
To: netdev
Cc: Jim Dykman, Piyush Chaudhary, Fu-Chung Chang, William S. Cadden,
Wen C. Chen, Scot Sakolish, Jian Xiao, Carol L. Soto,
Sarah J. Sheppard
In-Reply-To: <1303096919-7367-1-git-send-email-dykmanj@linux.vnet.ibm.com>
From: Jim Dykman <dykmanj@linux.vnet.ibm.com>
H_HFI_START_INTERFACE Notifies the hypervisor that a new instance of the DD is
starting, and any leftover state should be considered stale.
H_HFI_STOP_INTERFACE tells the hypervisor that the DD is unloading, and to
clean up any activity related to this DD instance.
H_HFI_QUERY_INTERFACE lets us get info about the HFIs that is not in the
device tree.
Signed-off-by: Piyush Chaudhary <piyushc@linux.vnet.ibm.com>
Signed-off-by: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
Signed-off-by: William S. Cadden <wscadden@linux.vnet.ibm.com>
Signed-off-by: Wen C. Chen <winstonc@linux.vnet.ibm.com>
Signed-off-by: Scot Sakolish <sakolish@linux.vnet.ibm.com>
Signed-off-by: Jian Xiao <jian@linux.vnet.ibm.com>
Signed-off-by: Carol L. Soto <clsoto@linux.vnet.ibm.com>
Signed-off-by: Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
---
drivers/net/hfi/core/Makefile | 3 +-
drivers/net/hfi/core/hfidd_adpt.c | 139 +++++++++++++++++++++++++++++++++++
drivers/net/hfi/core/hfidd_hcalls.c | 90 ++++++++++++++++++++++
drivers/net/hfi/core/hfidd_proto.h | 12 +++
include/linux/hfi/hfidd_client.h | 8 ++
include/linux/hfi/hfidd_hcalls.h | 58 +++++++++++++++
include/linux/hfi/hfidd_internal.h | 7 ++-
7 files changed, 315 insertions(+), 2 deletions(-)
create mode 100644 drivers/net/hfi/core/hfidd_hcalls.c
create mode 100644 include/linux/hfi/hfidd_hcalls.h
diff --git a/drivers/net/hfi/core/Makefile b/drivers/net/hfi/core/Makefile
index 6fe4e60..4e6cbd6 100644
--- a/drivers/net/hfi/core/Makefile
+++ b/drivers/net/hfi/core/Makefile
@@ -2,5 +2,6 @@
# Makefile for the HFI device driver for IBM eServer System p
#
hfi_core-objs:= hfidd_adpt.o \
- hfidd_init.o
+ hfidd_init.o \
+ hfidd_hcalls.o
obj-$(CONFIG_HFI) += hfi_core.o
diff --git a/drivers/net/hfi/core/hfidd_adpt.c b/drivers/net/hfi/core/hfidd_adpt.c
index 45e0c31..d2bef84 100644
--- a/drivers/net/hfi/core/hfidd_adpt.c
+++ b/drivers/net/hfi/core/hfidd_adpt.c
@@ -33,6 +33,18 @@
#include <linux/hfi/hfidd_internal.h>
#include "hfidd_proto.h"
+#define HFIDD_TIME_AGE (10 * HZ)
+
+int hfidd_age_hcall(u64 time_start)
+{
+ u64 timestamp = get_jiffies_64();
+
+ if ((timestamp - time_start) > HFIDD_TIME_AGE)
+ return 1;
+ else
+ return 0;
+}
+
int hfidd_alloc_adapter(struct hfidd_acs **adpt, dev_t devno, void *uiop)
{
@@ -66,3 +78,130 @@ void hfidd_free_adapter(struct hfidd_acs *p_acs)
{
kfree(p_acs);
}
+
+/* Allocate the page for the HCALL */
+int hfidd_get_phyp_page(struct hfidd_acs *p_acs, caddr_t *page, caddr_t *laddr,
+ int size)
+{
+ *page = (caddr_t)__get_free_pages(GFP_KERNEL, get_order(size));
+ if (*page == NULL) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_get_phyp_page: __get_free_pages failed\n");
+ return -ENOMEM;
+ }
+
+ /* translate virtual to logical address */
+ *laddr = (caddr_t)__pa((caddr_t) *page);
+ memset(*page, 0, size);
+ return 0;
+}
+
+/* Release the page allocated for the HCALL */
+inline void hfidd_release_phyp_page(caddr_t page, int size)
+{
+ free_pages((unsigned long)page, get_order(size));
+}
+
+int hfidd_query_interface(struct hfidd_acs *p_acs, unsigned int subtype,
+ unsigned int hfi_id, unsigned long long *state)
+{
+ long long hvrc;
+ int rc = 0;
+ struct hfi_query_interface *query_p;
+ caddr_t laddr = NULL;
+
+ if (subtype != COMP_QUERY && subtype != EEH_QUERY) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_query_interface: subtype not supported, %d\n",
+ subtype);
+ return -EINVAL;
+ }
+
+ if (subtype == COMP_QUERY) {
+ /* Allocate the page for the HCALL */
+ rc = hfidd_get_phyp_page(p_acs, (caddr_t *)&query_p, &laddr,
+ PAGE_SIZE_4K);
+ if (rc) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_query_interface: hfidd_get_phyp_page "
+ "failed\n");
+ return -ENOMEM;
+ }
+ }
+
+ hvrc = hfi_hquery_interface(hfi_id, subtype,
+ (unsigned long long)laddr, state);
+ if (hvrc != H_SUCCESS) {
+ rc = -EPERM;
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_query_interface: failed, state 0x%llx "
+ "hvrc 0x%llx\n", *state, hvrc);
+ goto query1;
+ }
+
+ if (subtype == COMP_QUERY) {
+ if (*state == ACTIVE) {
+ if (p_acs->state != HFI_AVAIL) {
+ p_acs->isr = query_p->local_node_id;
+ p_acs->state = HFI_AVAIL;
+ }
+ } else {
+ p_acs->state = HFI_UNAVAIL;
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_query_interface: Bad state %lld, "
+ "return ENODEV\n", *state);
+ rc = -EIO;
+ }
+ }
+
+query1:
+ if (subtype == COMP_QUERY)
+ hfidd_release_phyp_page((caddr_t)query_p, PAGE_SIZE_4K);
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "hfidd_query_interface: return rc %d\n", rc);
+ return rc;
+}
+
+int hfidd_start_interface(struct hfidd_acs *p_acs)
+{
+ long long hvrc = 0;
+ int rc = 0;
+ u64 start_time = get_jiffies_64();
+
+ while (1) {
+ hvrc = hfi_start_interface(p_acs->dds.hfi_id);
+ if (hvrc != H_BUSY)
+ break;
+ if (hfidd_age_hcall(start_time))
+ break;
+ }
+ if (hvrc != H_SUCCESS) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_start_interface: HFI_START_INTERFACE failed "
+ "hvrc 0x%llx\n", hvrc);
+ rc = -EPERM;
+ }
+ return rc;
+}
+
+int hfidd_stop_interface(struct hfidd_acs *p_acs, unsigned int hfi_id)
+{
+ long long hvrc = 0;
+ int rc = 0;
+ u64 start_time = get_jiffies_64();
+
+ while (1) {
+ hvrc = hfi_stop_interface(hfi_id);
+ if (hvrc != H_BUSY)
+ break;
+ if (hfidd_age_hcall(start_time))
+ break;
+ }
+ if (hvrc != H_SUCCESS) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_stop_interface: HFI_STOP_INTERFACE failed "
+ "hvrc 0x%llx\n", hvrc);
+ rc = -EPERM;
+ }
+ return rc;
+}
diff --git a/drivers/net/hfi/core/hfidd_hcalls.c b/drivers/net/hfi/core/hfidd_hcalls.c
new file mode 100644
index 0000000..84467b3
--- /dev/null
+++ b/drivers/net/hfi/core/hfidd_hcalls.c
@@ -0,0 +1,90 @@
+/*
+ * hfidd_hcalls.c
+ *
+ * HFI device driver for IBM System p
+ *
+ * Authors:
+ * Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
+ * William S. Cadden <wscadden@linux.vnet.ibm.com>
+ * Wen C. Chen <winstonc@linux.vnet.ibm.com>
+ * Scot Sakolish <sakolish@linux.vnet.ibm.com>
+ * Jian Xiao <jian@linux.vnet.ibm.com>
+ * Carol L. Soto <clsoto@linux.vnet.ibm.com>
+ * Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
+ *
+ * (C) Copyright IBM Corp. 2010
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include <linux/hfi/hfidd_internal.h>
+#include "hfidd_proto.h"
+
+static inline long long h_hfi_start_interface(int token,
+ u64 HFI_chip_ID)
+{
+ return plpar_hcall_norets(token, HFI_chip_ID);
+}
+
+static inline long long h_hfi_stop_interface(int token,
+ u64 HFI_chip_ID)
+{
+ return plpar_hcall_norets(token, HFI_chip_ID);
+}
+
+static inline long long h_hfi_query_interface(int token,
+ u64 HFI_chip_ID,
+ u64 type,
+ u64 output_page_ptr,
+ u64 *state)
+{
+ long long rc;
+ u64 hyp_outputs[PLPAR_HCALL_BUFSIZE];
+
+ rc = plpar_hcall(token, (unsigned long *)hyp_outputs, HFI_chip_ID, type,
+ output_page_ptr);
+ *state = hyp_outputs[0]; /* 1st ret value */
+
+ return rc;
+}
+
+long long hfi_hquery_interface(u64 unit_id, u64 subtype,
+ u64 query_p, u64 *state)
+{
+ long long hvrc;
+
+ hvrc = h_hfi_query_interface(H_HFI_QUERY_INTERFACE,
+ unit_id,
+ subtype,
+ query_p,
+ state);
+ return hvrc;
+}
+
+long long hfi_start_interface(u64 unit_id)
+{
+ return h_hfi_start_interface(H_HFI_START_INTERFACE,
+ unit_id);
+}
+
+long long hfi_stop_interface(u64 unit_id)
+{
+ long long hvrc;
+
+ hvrc = h_hfi_stop_interface(H_HFI_STOP_INTERFACE,
+ unit_id);
+ return hvrc;
+}
diff --git a/drivers/net/hfi/core/hfidd_proto.h b/drivers/net/hfi/core/hfidd_proto.h
index e2ed4c9..6ec9245 100644
--- a/drivers/net/hfi/core/hfidd_proto.h
+++ b/drivers/net/hfi/core/hfidd_proto.h
@@ -36,5 +36,17 @@
int hfidd_alloc_adapter(struct hfidd_acs **adpt, dev_t, void *uiop);
void hfidd_free_adapter(struct hfidd_acs *p_acs);
int hfidd_init_adapter(struct hfidd_acs *p_acs, void *uiop);
+int hfidd_age_hcall(u64 time_start);
+int hfidd_get_phyp_page(struct hfidd_acs *p_acs, caddr_t *page,
+ caddr_t *laddr, int size);
+void hfidd_release_phyp_page(caddr_t page, int size);
+int hfidd_query_interface(struct hfidd_acs *p_acs, unsigned int subtype,
+ unsigned int hfi_id, unsigned long long *state);
+int hfidd_start_interface(struct hfidd_acs *p_acs);
+int hfidd_stop_interface(struct hfidd_acs *p_acs, unsigned int hfi_id);
+long long hfi_hquery_interface(u64 unit_id, u64 subtype, u64 query_p,
+ u64 *state);
+long long hfi_start_interface(u64 unit_id);
+long long hfi_stop_interface(u64 unit_id);
#endif
diff --git a/include/linux/hfi/hfidd_client.h b/include/linux/hfi/hfidd_client.h
index 28f1693..2714a27 100644
--- a/include/linux/hfi/hfidd_client.h
+++ b/include/linux/hfi/hfidd_client.h
@@ -40,4 +40,12 @@
#define HFI_DYN_WINS_DEFAULT 32
+#define PAGE_SIZE_4K 0x1000
+#define PAGE_SIZE_64K 0x10000
+#define PAGE_SIZE_1M 0x100000
+#define PAGE_SIZE_16M 0x1000000
+#define PAGE_SIZE_256M 0x10000000
+#define PAGE_SIZE_4G 0x100000000
+#define PAGE_SIZE_16G 0x400000000
+
#endif /* _HFIDD_CLIENT_H_ */
diff --git a/include/linux/hfi/hfidd_hcalls.h b/include/linux/hfi/hfidd_hcalls.h
new file mode 100644
index 0000000..5349e9e
--- /dev/null
+++ b/include/linux/hfi/hfidd_hcalls.h
@@ -0,0 +1,58 @@
+/*
+ * hfidd_hcalls.h
+ *
+ * HFI device driver for IBM System p
+ *
+ * Authors:
+ * Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
+ * William S. Cadden <wscadden@linux.vnet.ibm.com>
+ * Wen C. Chen <winstonc@linux.vnet.ibm.com>
+ * Scot Sakolish <sakolish@linux.vnet.ibm.com>
+ * Jian Xiao <jian@linux.vnet.ibm.com>
+ * Carol L. Soto <clsoto@linux.vnet.ibm.com>
+ * Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
+ *
+ * (C) Copyright IBM Corp. 2010
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#ifndef _HFIDD_HCALLS_H_
+#define _HFIDD_HCALLS_H_
+
+#include <asm/hvcall.h>
+
+/* Token IDs */
+#define H_HFI_START_INTERFACE 0xF000
+#define H_HFI_QUERY_INTERFACE 0xF004
+#define H_HFI_STOP_INTERFACE 0xF008
+
+#define EEH_QUERY 1
+#define COMP_QUERY 2
+
+/* States of Query interface */
+#define NOT_READY 0
+#define NOT_STARTED 1
+#define ACTIVE 2
+#define CLOSING 3
+#define ERROR 101
+
+struct hfi_query_interface {
+ unsigned long long hypervisor_capabilities;
+ unsigned int local_node_id;
+};
+
+#endif /* _HFIDD_HCALLS_H_ */
diff --git a/include/linux/hfi/hfidd_internal.h b/include/linux/hfi/hfidd_internal.h
index fafca96..8fe313d 100644
--- a/include/linux/hfi/hfidd_internal.h
+++ b/include/linux/hfi/hfidd_internal.h
@@ -39,10 +39,12 @@
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/slab.h>
+#include <linux/jiffies.h>
+#include <linux/device.h>
#include <linux/hfi/hfidd_client.h>
#include <linux/hfi/hfidd_adpt.h>
-
+#include <linux/hfi/hfidd_hcalls.h>
#define HFIDD_DEV_NAME "hfi"
#define HFIDD_CLASS_NAME "hfi"
@@ -65,6 +67,9 @@ struct hfidd_acs {
unsigned int index;
unsigned int acs_cnt;
unsigned int state;
+
+ unsigned int isr;
+
struct device *hfidd_dev;
struct hfidd_dds dds;
};
--
1.7.3.5
^ permalink raw reply related
* [PATCH v2 19/27] HFI: Add window close request
From: dykmanj @ 2011-04-18 3:21 UTC (permalink / raw)
To: netdev
Cc: Jim Dykman, Piyush Chaudhary, Fu-Chung Chang, William S. Cadden,
Wen C. Chen, Scot Sakolish, Jian Xiao, Carol L. Soto,
Sarah J. Sheppard
In-Reply-To: <1303096919-7367-1-git-send-email-dykmanj@linux.vnet.ibm.com>
From: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Piyush Chaudhary <piyushc@linux.vnet.ibm.com>
Signed-off-by: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
Signed-off-by: William S. Cadden <wscadden@linux.vnet.ibm.com>
Signed-off-by: Wen C. Chen <winstonc@linux.vnet.ibm.com>
Signed-off-by: Scot Sakolish <sakolish@linux.vnet.ibm.com>
Signed-off-by: Jian Xiao <jian@linux.vnet.ibm.com>
Signed-off-by: Carol L. Soto <clsoto@linux.vnet.ibm.com>
Signed-off-by: Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
---
drivers/net/hfi/core/hfidd_init.c | 36 +++++++++
drivers/net/hfi/core/hfidd_proto.h | 4 +
drivers/net/hfi/core/hfidd_window.c | 148 +++++++++++++++++++++++++++++++++++
include/linux/hfi/hfidd_client.h | 8 ++
include/linux/hfi/hfidd_hcalls.h | 1 +
include/linux/hfi/hfidd_requests.h | 1 +
6 files changed, 198 insertions(+), 0 deletions(-)
diff --git a/drivers/net/hfi/core/hfidd_init.c b/drivers/net/hfi/core/hfidd_init.c
index 197fcc3..783ce1b 100644
--- a/drivers/net/hfi/core/hfidd_init.c
+++ b/drivers/net/hfi/core/hfidd_init.c
@@ -79,6 +79,20 @@ static int hfidd_query_dd_info(struct hfidd_acs *p_acs,
return rc;
}
+/*
+ * This function is to check which command will be allowed after we got
+ * hfi error.
+ */
+static inline int valid_cmd_for_hfi_error(int cmd)
+{
+ switch (cmd) {
+ case HFIDD_REQ_CLOSE_WINDOW:
+ return 0;
+ default:
+ return -1;
+ }
+}
+
/* Entry point for user space to do driver requests. */
static ssize_t hfidd_cmd_write(struct file *filep, const char __user *buf,
size_t count, loff_t *pos)
@@ -129,6 +143,15 @@ static ssize_t hfidd_cmd_write(struct file *filep, const char __user *buf,
return -EINVAL;
}
+ if (p_acs->state != HFI_AVAIL) {
+ if (valid_cmd_for_hfi_error(cmd.req)) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_write_cmd: hfi%d not avail, "
+ "state 0x%x for cmd 0x%x\n",
+ p_acs->index, p_acs->state, cmd.req);
+ return -EIO;
+ }
+ }
switch (cmd.req) {
case HFIDD_REQ_OPEN_WINDOW:
if (cmd.req_len != sizeof(struct hfi_client_info)) {
@@ -144,6 +167,19 @@ static ssize_t hfidd_cmd_write(struct file *filep, const char __user *buf,
(struct hfi_client_info *) cmd.result.use.kptr);
break;
+ case HFIDD_REQ_CLOSE_WINDOW:
+ if (cmd.req_len != sizeof(struct hfi_window_info)) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_cmd_write: hdr.reqlen 0x%x expected "
+ "0x%lx for cmd req 0x%x\n",
+ cmd.req_len,
+ sizeof(struct hfi_window_info), cmd.req);
+ return -EINVAL;
+ }
+ rc = hfidd_close_window_func(p_acs, is_userspace,
+ (struct hfi_window_info *) buf);
+ break;
+
case HFIDD_REQ_QUERY_DD_INFO:
if (cmd.req_len != sizeof(struct hfi_query_dd_info)) {
dev_printk(KERN_ERR, p_acs->hfidd_dev,
diff --git a/drivers/net/hfi/core/hfidd_proto.h b/drivers/net/hfi/core/hfidd_proto.h
index 1f7fe80..e065d56 100644
--- a/drivers/net/hfi/core/hfidd_proto.h
+++ b/drivers/net/hfi/core/hfidd_proto.h
@@ -54,6 +54,10 @@ int hfidd_get_page_num(struct hfidd_acs *p_acs, void *start_addr,
int hfidd_open_window_func(struct hfidd_acs *p_acs, unsigned int is_userspace,
struct hfi_client_info *user_p,
struct hfi_client_info *out_p);
+int hfidd_close_window_internal(struct hfidd_acs *p_acs,
+ unsigned int is_userspace, unsigned int win_num);
+int hfidd_close_window_func(struct hfidd_acs *p_acs, unsigned int is_userspace,
+ struct hfi_window_info *user_p);
int hfi_register_rpages(struct hfidd_acs *p_acs, unsigned long long mr_handle,
unsigned int submr, struct hfidd_vlxmem *xtab_p,
unsigned int *mapped_pages);
diff --git a/drivers/net/hfi/core/hfidd_window.c b/drivers/net/hfi/core/hfidd_window.c
index 5d319a1..3cfe5c3 100644
--- a/drivers/net/hfi/core/hfidd_window.c
+++ b/drivers/net/hfi/core/hfidd_window.c
@@ -874,6 +874,28 @@ setup_window_parm_err1:
return rc;
}
+/* Unmap the window mmio registers - only user space window */
+static int hfi_unmap_mmio_regs(struct hfidd_acs *p_acs,
+ struct hfidd_window *win_p,
+ unsigned int is_userspace)
+{
+ int rc = 0;
+
+ if (is_userspace) {
+ rc = hfidd_unmap((void *)
+ (win_p->client_info.mmio_regs.use.kptr),
+ PAGE_SIZE_64K);
+ if (rc) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfi_unmap_mmio_regs: hfidd_unmap failed "
+ "rc = 0x%x\n", rc);
+ return rc;
+ }
+ win_p->client_info.mmio_regs.use.kptr = NULL;
+ }
+ return 0;
+}
+
/* Map the window mmio registers - only user space window */
static int hfi_map_mmio_regs(struct hfidd_acs *p_acs,
unsigned int is_userspace,
@@ -1023,3 +1045,129 @@ hfidd_open_window_func_err1:
return rc;
}
EXPORT_SYMBOL_GPL(hfidd_open_window_func);
+
+/*
+ * Close an user/kernel window to stop send/receive network traffic thru
+ * HFI adapter. This function will call PHYP to close the window and
+ * release the system resources allocated during open time. This function
+ * is called by hfidd_close_window_func or by abnormal end handler when
+ * the process goes away.
+ */
+int hfidd_close_window_internal(struct hfidd_acs *p_acs,
+ unsigned int is_userspace, unsigned int win_num)
+{
+ struct hfidd_window *win_p;
+ int rc = 0;
+
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "close_window_internal: win_num=0x%x\n", win_num);
+
+ if ((win_num < min_hfi_windows(p_acs)) ||
+ (win_num >= max_hfi_windows(p_acs))) {
+ rc = -EINVAL;
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "close_window_internal: window too large - "
+ "0x%x rc = 0x%x\n", win_num, rc);
+ goto hfidd_close_window_internal_err0;
+ }
+
+ win_p = hfi_window(p_acs, win_num);
+ if (win_p == NULL) {
+ rc = -ENOENT;
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "close_window_internal: win_p is NULL rc=0x%x\n", rc);
+ goto hfidd_close_window_internal_err0;
+ }
+
+ spin_lock(&(win_p->win_lock));
+
+ /* Make sure state is open or error state. */
+ if ((win_p->state != WIN_OPENED) &&
+ (win_p->state != WIN_SUSPENDED) &&
+ (win_p->state != WIN_ERROR) &&
+ (win_p->state != WIN_HERROR)) {
+ rc = -EFAULT;
+ spin_unlock(&(win_p->win_lock));
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_close_window_internal: bad window state=0x%x, "
+ "rc = 0x%x\n", win_p->state, rc);
+ goto hfidd_close_window_internal_err0;
+ }
+ spin_unlock(&(win_p->win_lock));
+
+ rc = hfi_unmap_mmio_regs(p_acs, win_p, is_userspace);
+ if (rc) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_close_window_internal: hfi_unmap_mmio_regs "
+ "failed, rc = 0x%x\n", rc);
+ goto hfidd_close_window_internal_err0;
+ }
+
+ hfi_destroy_window_info(p_acs, win_p);
+
+ /* Call hcall to unregister MR in the MMU */
+ rc = hfi_takedown_window_in_MMU(p_acs, is_userspace, win_p);
+ if (rc) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_close_window_internal: hfi_takedown_window_in_MMU "
+ "failed, rc = 0x%x\n", rc);
+ goto hfidd_close_window_internal_err0;
+ }
+
+ hfi_free_win_resource(p_acs, is_userspace, win_p,
+ &(win_p->client_info));
+
+ spin_lock(&win_p->win_lock);
+ /* Update the window information */
+ hfi_restore_window_parm(p_acs, win_p);
+ spin_unlock(&win_p->win_lock);
+
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "close_window_internal: type=0x%x state=0x%x JobID=0x%x\n",
+ win_p->type, win_p->state, win_p->job_id);
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "close_window_internal: rc=0x%x\n", rc);
+ return rc;
+
+hfidd_close_window_internal_err0:
+ return rc;
+}
+
+/*
+ * This function is called by the kernel users directly or a write
+ * system call by the kernel users. It will call hfidd_close_window_internal
+ * to close a specific window.
+ */
+int hfidd_close_window_func(struct hfidd_acs *p_acs, unsigned int is_userspace,
+ struct hfi_window_info *user_p)
+{
+ unsigned int win_num;
+ int rc = 0;
+ struct hfi_window_info win_info;
+
+ /* Copy in win num from user */
+ rc = hfi_copy_from_user(&win_info, user_p,
+ is_userspace, sizeof(struct hfi_window_info));
+ if (rc) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_close_window_func: hfi_copy_from_user "
+ "failed, rc = 0x%x\n", rc);
+ return rc;
+ }
+
+ win_num = win_info.window;
+
+ rc = hfidd_close_window_internal(p_acs, is_userspace, win_num);
+ if (rc) {
+ rc = -EINVAL;
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_close_window_func: close_window_internal "
+ "failed, win=0x%x rc=0x%x\n", win_num, rc);
+ return rc;
+ }
+
+ dev_printk(KERN_INFO, p_acs->hfidd_dev,
+ "close_window_func: rc=0x%x\n", rc);
+ return rc;
+}
+EXPORT_SYMBOL_GPL(hfidd_close_window_func);
diff --git a/include/linux/hfi/hfidd_client.h b/include/linux/hfi/hfidd_client.h
index 7e4c1a7..11c8973 100644
--- a/include/linux/hfi/hfidd_client.h
+++ b/include/linux/hfi/hfidd_client.h
@@ -113,6 +113,14 @@ struct hfi_client_info {
struct hfi_64b mmio_regs; /* Output */
};
+/*
+ * HFIDD_REQ_CLOSE_WINDOW: close window
+ */
+struct hfi_window_info {
+ struct hfi_req_hdr hdr;
+ unsigned int window;
+};
+
#define MAX_TORRENTS 1
#define MAX_HFI_PER_TORRENT 2
#define MAX_HFIS (MAX_TORRENTS * MAX_HFI_PER_TORRENT)
diff --git a/include/linux/hfi/hfidd_hcalls.h b/include/linux/hfi/hfidd_hcalls.h
index 1e007c5..777de8f 100644
--- a/include/linux/hfi/hfidd_hcalls.h
+++ b/include/linux/hfi/hfidd_hcalls.h
@@ -40,6 +40,7 @@
#define H_HFI_QUERY_INTERFACE 0xF004
#define H_HFI_STOP_INTERFACE 0xF008
#define H_HFI_OPEN_WINDOW 0xF00C
+#define H_HFI_CLOSE_WINDOW 0xF014
#define H_NMMU_START 0xF028
#define H_NMMU_STOP 0xF02C
#define H_NMMU_ALLOCATE_RESOURCE 0xF030
diff --git a/include/linux/hfi/hfidd_requests.h b/include/linux/hfi/hfidd_requests.h
index 4f1c74d..a7a38da 100644
--- a/include/linux/hfi/hfidd_requests.h
+++ b/include/linux/hfi/hfidd_requests.h
@@ -35,5 +35,6 @@
#define HFIDD_REQ_OPEN_WINDOW 0x00000a01
#define HFIDD_REQ_QUERY_DD_INFO 0x00001004
+#define HFIDD_REQ_CLOSE_WINDOW 0x00000a02
#endif /* _HFIDD_REQUESTS_H_ */
--
1.7.3.5
^ permalink raw reply related
* [PATCH v2 12/27] HFI: Sanity check send and receive fifo parameters
From: dykmanj @ 2011-04-18 3:21 UTC (permalink / raw)
To: netdev
Cc: Jim Dykman, Piyush Chaudhary, Fu-Chung Chang, William S. Cadden,
Wen C. Chen, Scot Sakolish, Jian Xiao, Carol L. Soto,
Sarah J. Sheppard
In-Reply-To: <1303096919-7367-1-git-send-email-dykmanj@linux.vnet.ibm.com>
From: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Piyush Chaudhary <piyushc@linux.vnet.ibm.com>
Signed-off-by: Jim Dykman <dykmanj@linux.vnet.ibm.com>
Signed-off-by: Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
Signed-off-by: William S. Cadden <wscadden@linux.vnet.ibm.com>
Signed-off-by: Wen C. Chen <winstonc@linux.vnet.ibm.com>
Signed-off-by: Scot Sakolish <sakolish@linux.vnet.ibm.com>
Signed-off-by: Jian Xiao <jian@linux.vnet.ibm.com>
Signed-off-by: Carol L. Soto <clsoto@linux.vnet.ibm.com>
Signed-off-by: Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
---
drivers/net/hfi/core/Makefile | 1 +
drivers/net/hfi/core/hfidd_proto.h | 3 +
drivers/net/hfi/core/hfidd_window.c | 177 +++++++++++++++++++++++++++++++++++
drivers/net/hfi/core/hfidd_xlat.c | 131 ++++++++++++++++++++++++++
include/linux/hfi/hfidd_adpt.h | 17 ++++
5 files changed, 329 insertions(+), 0 deletions(-)
create mode 100644 drivers/net/hfi/core/hfidd_xlat.c
diff --git a/drivers/net/hfi/core/Makefile b/drivers/net/hfi/core/Makefile
index 0224a57..8d5558d 100644
--- a/drivers/net/hfi/core/Makefile
+++ b/drivers/net/hfi/core/Makefile
@@ -4,5 +4,6 @@
hfi_core-objs:= hfidd_adpt.o \
hfidd_window.o \
hfidd_init.o \
+ hfidd_xlat.o \
hfidd_hcalls.o
obj-$(CONFIG_HFI) += hfi_core.o
diff --git a/drivers/net/hfi/core/hfidd_proto.h b/drivers/net/hfi/core/hfidd_proto.h
index e7f2901..66ea5da 100644
--- a/drivers/net/hfi/core/hfidd_proto.h
+++ b/drivers/net/hfi/core/hfidd_proto.h
@@ -39,6 +39,9 @@ int hfidd_alloc_windows(struct hfidd_acs *p_acs);
void hfidd_free_windows(struct hfidd_acs *p_acs);
int hfidd_init_adapter(struct hfidd_acs *p_acs, void *uiop);
int hfidd_age_hcall(u64 time_start);
+int hfidd_get_page_size(struct hfidd_acs *p_acs, void *addr,
+ unsigned int is_userspace, unsigned int length,
+ unsigned long long *page_size);
int hfidd_open_window_func(struct hfidd_acs *p_acs, unsigned int is_userspace,
struct hfi_client_info *user_p,
struct hfi_client_info *out_p);
diff --git a/drivers/net/hfi/core/hfidd_window.c b/drivers/net/hfi/core/hfidd_window.c
index cc775e3..5a4f395 100644
--- a/drivers/net/hfi/core/hfidd_window.c
+++ b/drivers/net/hfi/core/hfidd_window.c
@@ -35,6 +35,153 @@
#include "hfidd_proto.h"
#include <linux/hfi/hfidd_requests.h>
+#define FINISH_VECTOR_LENGTH 1
+/* Validate send fifo parameters needed for open window */
+static int hfi_check_sfifo_parm(struct hfidd_acs *p_acs,
+ unsigned int is_userspace,
+ struct hfidd_window *win_p,
+ struct hfi_client_info *client_p)
+{
+ int rc = 0;
+ unsigned long long page_sz;
+ unsigned long long fv_page_sz;
+
+ /* Validate the sfifo size */
+ if ((client_p->sfifo.size < HFI_SFIFO_SIZE_MIN) ||
+ (client_p->sfifo.size > HFI_SFIFO_SIZE_MAX)) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfi_check_sfifo_parm: invalid sfifo "
+ "size = 0x%llx\n",
+ client_p->sfifo.size);
+ return -EINVAL;
+ }
+
+ /*
+ * Validate the address of sfifo is 4k aligned, and finish vector
+ * is cache-line aligned
+ */
+ if ((client_p->sfifo.eaddr.use.allu) & PAGE_MASK_4K) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfi_check_sfifo_parm: not page aligned, "
+ "sfifo_addr = 0x%llx\n",
+ client_p->sfifo.eaddr.use.allu);
+ return -EINVAL;
+ }
+
+ if ((client_p->sfifo_finish_vec.use.allu) & HFI_CACHE_LINE_MASK) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfi_check_sfifo_parm: not cache aligned, "
+ "sfifo_finishvec = 0x%llx\n",
+ client_p->sfifo_finish_vec.use.allu);
+ return -EINVAL;
+ }
+ /*
+ * Validate the send finish vector are within 4K bytes of end of sfifo
+ */
+ if (((client_p->sfifo_finish_vec.use.kptr -
+ (client_p->sfifo.eaddr.use.kptr +
+ client_p->sfifo.size)) >= PAGE_SIZE_4K)) {
+
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfi_check_sfifo_parm: fv too far away, "
+ "sfifo_addr = 0x%llx\n",
+ client_p->sfifo.eaddr.use.allu);
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfi_check_sfifo_parm: fv too far away, "
+ "sfifo_finishvec = 0x%llx\n",
+ client_p->sfifo_finish_vec.use.allu);
+ return -EINVAL;
+ }
+
+ /* Validate page size of sFifo */
+ rc = hfidd_get_page_size(p_acs, client_p->sfifo.eaddr.use.kptr,
+ is_userspace, client_p->sfifo.size, &page_sz);
+ if (rc) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfi_check_sfifo_parm: fail in sfifo page size, "
+ "rc=0x%x\n", rc);
+ return rc;
+ }
+
+ /* Find out the page size of send finish vector */
+ rc = hfidd_get_page_size(p_acs, client_p->sfifo_finish_vec.use.kptr,
+ is_userspace, FINISH_VECTOR_LENGTH, &fv_page_sz);
+ if (rc) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfi_check_sfifo_parm: fail in fv page size, "
+ "rc=0x%x\n", rc);
+ return rc;
+ }
+
+ /* The page size of finish vector must be the same as sfifo */
+ if (page_sz != fv_page_sz) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfi_check_sfifo_parm: diff page sz sf=0x%llx, "
+ "fv0=0x%llx\n", page_sz, fv_page_sz);
+ return -EINVAL;
+ }
+ return 0;
+}
+
+static int hfi_check_rfifo_parm(struct hfidd_acs *p_acs,
+ unsigned int is_userspace,
+ struct hfidd_window *win_p,
+ struct hfi_client_info *client_p)
+{
+ int rc = 0;
+ unsigned long long page_sz;
+
+ /* Validate the rfifo size */
+ if ((client_p->rfifo.size < HFI_RFIFO_SIZE_MIN) ||
+ (client_p->rfifo.size > HFI_RFIFO_SIZE_MAX)) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfi_check_rfifo_parm: invalid rfifo size = 0x%llx\n",
+ client_p->rfifo.size);
+ return -EINVAL;
+ }
+
+ /* Validate the address of rfifo is 4K aligned */
+ if ((client_p->rfifo.eaddr.use.allu) & PAGE_MASK_4K) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfi_check_rfifo_parm: not cache aligned, "
+ "rfifo_addr = 0x%llx\n",
+ client_p->rfifo.eaddr.use.allu);
+ return -EINVAL;
+ }
+
+ /* Validate page size of rFifo */
+ rc = hfidd_get_page_size(p_acs, client_p->rfifo.eaddr.use.kptr,
+ is_userspace, client_p->rfifo.size, &page_sz);
+ if (rc) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfi_check_rfifo_parm: fail in rfifo page size, "
+ "rc=0x%x\n", rc);
+ return rc;
+ }
+ return 0;
+}
+
+/* Validate window parameters to setup the fifos and RDMA function */
+static int hfi_validate_window_request(struct hfidd_acs *p_acs,
+ unsigned int is_userspace, struct hfi_client_info *client_p)
+{
+ int rc = 0;
+ struct hfidd_window *win_p;
+
+ /* Check every input parameters..... */
+ win_p = hfi_window(p_acs, client_p->window);
+
+ /* Check the request of sFifo */
+ rc = hfi_check_sfifo_parm(p_acs, is_userspace, win_p, client_p);
+ if (rc)
+ return rc;
+ /* Check the request of rFifo */
+ rc = hfi_check_rfifo_parm(p_acs, is_userspace, win_p, client_p);
+ if (rc)
+ return rc;
+ return rc;
+}
+
/* Validate the type, state and job id for RESERVED window */
static int hfi_validate_reserve_window_id(struct hfidd_acs *p_acs,
struct hfi_client_info *client_p)
@@ -164,12 +311,29 @@ static inline int hfi_validate_window_id(struct hfidd_acs *p_acs,
return rc;
}
+static inline void hfi_restore_window_parm(struct hfidd_acs *p_acs,
+ struct hfidd_window *win_p)
+{
+ if (win_p->type != HFIDD_RESERVE_WIN) {
+ win_p->type = HFIDD_DYNAMIC_WIN;
+ win_p->job_id = 0;
+ if (win_p->state != WIN_HERROR)
+ win_p->state = WIN_AVAILABLE;
+ } else {
+ if (win_p->state != WIN_HERROR)
+ win_p->state = WIN_RESERVED;
+ }
+ win_p->pid = 0;
+ win_p->is_ip = 0;
+}
+
/* Validate window number and type for open window request */
static int hfi_validate_window_parm(struct hfidd_acs *p_acs,
unsigned int is_userspace,
struct hfi_client_info *client_p)
{
int rc = 0;
+ struct hfidd_window *win_p;
/* Validate the window number */
rc = hfi_validate_window_id(p_acs, client_p, is_userspace);
@@ -179,6 +343,19 @@ static int hfi_validate_window_parm(struct hfidd_acs *p_acs,
"failed, rc = 0x%x\n", rc);
return rc;
}
+
+ rc = hfi_validate_window_request(p_acs, is_userspace, client_p);
+ if (rc) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfi_validate_window_parm: "
+ "hfi_validate_window_request failed, rc = 0x%x\n", rc);
+ win_p = hfi_window(p_acs, client_p->window);
+ spin_lock(&(win_p->win_lock));
+ hfi_restore_window_parm(p_acs, win_p);
+ spin_unlock(&(win_p->win_lock));
+ return rc;
+ }
+
return 0;
}
diff --git a/drivers/net/hfi/core/hfidd_xlat.c b/drivers/net/hfi/core/hfidd_xlat.c
new file mode 100644
index 0000000..23236cc
--- /dev/null
+++ b/drivers/net/hfi/core/hfidd_xlat.c
@@ -0,0 +1,131 @@
+/*
+ * hfidd_xlat.c
+ *
+ * HFI device driver for IBM System p
+ *
+ * Authors:
+ * Fu-Chung Chang <fcchang@linux.vnet.ibm.com>
+ * William S. Cadden <wscadden@linux.vnet.ibm.com>
+ * Wen C. Chen <winstonc@linux.vnet.ibm.com>
+ * Scot Sakolish <sakolish@linux.vnet.ibm.com>
+ * Jian Xiao <jian@linux.vnet.ibm.com>
+ * Carol L. Soto <clsoto@linux.vnet.ibm.com>
+ * Sarah J. Sheppard <sjsheppa@linux.vnet.ibm.com>
+ *
+ * (C) Copyright IBM Corp. 2010
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include <linux/pagemap.h>
+#include <linux/hugetlb.h>
+#include <asm/page.h>
+
+#include <linux/hfi/hfidd_internal.h>
+#include "hfidd_proto.h"
+
+int hfidd_get_page_size(struct hfidd_acs *p_acs, void *addr,
+ unsigned int is_userspace,
+ unsigned int length,
+ unsigned long long *page_size)
+{
+ int rc = 0;
+ int i;
+ int num_pages;
+ struct page **page_list;
+ struct vm_area_struct **vma_list;
+ unsigned long long offset;
+
+ if (!is_userspace) {
+ *page_size = PAGE_SIZE;
+ return 0;
+ }
+
+ offset = (unsigned long long)addr & ~PAGE_MASK;
+ num_pages = PAGE_ALIGN(length + offset) >> PAGE_SHIFT;
+
+ page_list = kzalloc(num_pages * sizeof(struct page *),
+ GFP_KERNEL);
+ if (page_list == NULL) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_get_page_size: kzalloc failed for page_list\n");
+ return -ENOMEM;
+ }
+
+ vma_list = kzalloc(num_pages * sizeof(struct vm_area_struct **),
+ GFP_KERNEL);
+ if (vma_list == NULL) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_get_page_size: kzalloc failed for vma_list\n");
+ rc = -ENOMEM;
+ goto out1;
+ }
+
+ down_read(¤t->mm->mmap_sem);
+ rc = get_user_pages(current, current->mm,
+ (unsigned long long)addr,
+ num_pages, 1, 0, /* yes write, no force */
+ page_list, vma_list);
+ up_read(¤t->mm->mmap_sem);
+
+ if (rc < num_pages) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_get_page_size: get_user_pages failed rc = %d "
+ "and numpages %d\n", rc, num_pages);
+ if (rc < 0)
+ goto out2;
+ num_pages = rc;
+ rc = -ENOMEM;
+ goto out3;
+ }
+
+ rc = 0;
+ *page_size = PAGE_SIZE;
+ for (i = 0; i < num_pages; i++) {
+ /* check for huge pages */
+ if (is_vm_hugetlb_page(vma_list[i])) {
+ /* Find huge page size */
+ *page_size = huge_page_size(hstate_vma(vma_list[i]));
+ break;
+ }
+ }
+
+ /* If memory has huge page size, check if all pages are huge pages */
+ if (*page_size != PAGE_SIZE) {
+ for (i = 0; i < num_pages; i++) {
+ /* if not huge page, set to PAGE_SIZE */
+ if (!is_vm_hugetlb_page(vma_list[i])) {
+ *page_size = PAGE_SIZE;
+ break;
+ }
+ }
+ }
+ if (*page_size == PAGE_SIZE_16G) {
+ dev_printk(KERN_ERR, p_acs->hfidd_dev,
+ "hfidd_get_page_size: Large page size "
+ "0x%llx use 4G\n", *page_size);
+ *page_size = PAGE_SIZE_4G;
+ }
+
+out3:
+ for (i = 0; i < num_pages; i++)
+ page_cache_release(page_list[i]);
+out2:
+ kfree(vma_list);
+out1:
+ kfree(page_list);
+ return rc;
+}
diff --git a/include/linux/hfi/hfidd_adpt.h b/include/linux/hfi/hfidd_adpt.h
index babdb14..a41825f 100644
--- a/include/linux/hfi/hfidd_adpt.h
+++ b/include/linux/hfi/hfidd_adpt.h
@@ -36,6 +36,16 @@
#include <linux/hfi/hfidd_client.h>
+#define HFI_SFIFO_SIZE_MIN 0x10000 /* min = 64K software limit */
+#define HFI_SFIFO_SIZE_MAX 0x800000 /* max = 8M */
+
+#define HFI_RFIFO_SIZE_MIN 0x1000 /* min = 4K */
+#define HFI_RFIFO_SIZE_MAX 0x8000000 /* max = 128M */
+
+#define HFI_CACHE_LINE_SIZE 0x80
+#define HFI_CACHE_LINE_MASK (HFI_CACHE_LINE_SIZE - 1)
+#define HFI_CACHE_LINE_SHIFT 7
+
#define HFI_WNUM_SHIFT 32
#define HFI_CAUNUM_SHIFT 32
#define HFI_SHIFT_OCTANT 3
@@ -57,4 +67,11 @@
#define WIN_PENDING 6
#define WIN_FAIL_CLOSE 7
+#define PAGE_MASK_4K (PAGE_SIZE_4K - 1)
+#define PAGE_MASK_64K (PAGE_SIZE_64K - 1)
+#define PAGE_MASK_1M (PAGE_SIZE_1M - 1)
+#define PAGE_MASK_16M (PAGE_SIZE_16M - 1)
+#define PAGE_MASK_4G (PAGE_SIZE_4G - 1)
+#define PAGE_MASK_16G (PAGE_SIZE_16G - 1)
+
#endif /* _HFIDD_ADPT_H_ */
--
1.7.3.5
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox