c0fc39620f3643c4393ba2b1d99c8181498b0da0
[pandora-kernel.git] / include / net / bluetooth / hci_core.h
1 /* 
2    BlueZ - Bluetooth protocol stack for Linux
3    Copyright (C) 2000-2001 Qualcomm Incorporated
4
5    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License version 2 as
9    published by the Free Software Foundation;
10
11    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
12    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
14    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
15    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 
16    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 
17    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 
18    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
20    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 
21    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 
22    SOFTWARE IS DISCLAIMED.
23 */
24
25 #ifndef __HCI_CORE_H
26 #define __HCI_CORE_H
27
28 #include <net/bluetooth/hci.h>
29
30 /* HCI upper protocols */
31 #define HCI_PROTO_L2CAP 0
32 #define HCI_PROTO_SCO   1
33
34 /* HCI Core structures */
35 struct inquiry_data {
36         bdaddr_t        bdaddr;
37         __u8            pscan_rep_mode;
38         __u8            pscan_period_mode;
39         __u8            pscan_mode;
40         __u8            dev_class[3];
41         __le16          clock_offset;
42         __s8            rssi;
43 };
44
45 struct inquiry_entry {
46         struct inquiry_entry    *next;
47         __u32                   timestamp;
48         struct inquiry_data     data;
49 };
50
51 struct inquiry_cache {
52         spinlock_t              lock;
53         __u32                   timestamp;
54         struct inquiry_entry    *list;
55 };
56
57 struct hci_conn_hash {
58         struct list_head list;
59         spinlock_t       lock;
60         unsigned int     acl_num;
61         unsigned int     sco_num;
62 };
63
64 struct hci_dev {
65         struct list_head list;
66         spinlock_t      lock;
67         atomic_t        refcnt;
68
69         char            name[8];
70         unsigned long   flags;
71         __u16           id;
72         __u8            type;
73         bdaddr_t        bdaddr;
74         __u8            features[8];
75         __u8            hci_ver;
76         __u16           hci_rev;
77         __u16           manufacturer;
78         __u16           voice_setting;
79
80         __u16           pkt_type;
81         __u16           link_policy;
82         __u16           link_mode;
83
84         __u32           idle_timeout;
85         __u16           sniff_min_interval;
86         __u16           sniff_max_interval;
87
88         unsigned long   quirks;
89
90         atomic_t        cmd_cnt;
91         unsigned int    acl_cnt;
92         unsigned int    sco_cnt;
93
94         unsigned int    acl_mtu;
95         unsigned int    sco_mtu;
96         unsigned int    acl_pkts;
97         unsigned int    sco_pkts;
98
99         unsigned long   cmd_last_tx;
100         unsigned long   acl_last_tx;
101         unsigned long   sco_last_tx;
102
103         struct tasklet_struct   cmd_task;
104         struct tasklet_struct   rx_task;
105         struct tasklet_struct   tx_task;
106
107         struct sk_buff_head     rx_q;
108         struct sk_buff_head     raw_q;
109         struct sk_buff_head     cmd_q;
110
111         struct sk_buff          *sent_cmd;
112
113         struct semaphore        req_lock;
114         wait_queue_head_t       req_wait_q;
115         __u32                   req_status;
116         __u32                   req_result;
117
118         struct inquiry_cache    inq_cache;
119         struct hci_conn_hash    conn_hash;
120
121         struct hci_dev_stats    stat;
122
123         struct sk_buff_head     driver_init;
124
125         void                    *driver_data;
126         void                    *core_data;
127
128         atomic_t                promisc;
129
130         struct device           *parent;
131         struct device           dev;
132
133         struct module           *owner;
134
135         int (*open)(struct hci_dev *hdev);
136         int (*close)(struct hci_dev *hdev);
137         int (*flush)(struct hci_dev *hdev);
138         int (*send)(struct sk_buff *skb);
139         void (*destruct)(struct hci_dev *hdev);
140         void (*notify)(struct hci_dev *hdev, unsigned int evt);
141         int (*ioctl)(struct hci_dev *hdev, unsigned int cmd, unsigned long arg);
142 };
143
144 struct hci_conn {
145         struct list_head list;
146
147         atomic_t         refcnt;
148         spinlock_t       lock;
149
150         bdaddr_t         dst;
151         __u16            handle;
152         __u16            state;
153         __u8             mode;
154         __u8             type;
155         __u8             out;
156         __u8             attempt;
157         __u8             dev_class[3];
158         __u8             features[8];
159         __u16            interval;
160         __u16            link_policy;
161         __u32            link_mode;
162         __u8             power_save;
163         unsigned long    pend;
164
165         unsigned int     sent;
166
167         struct sk_buff_head data_q;
168
169         struct timer_list disc_timer;
170         struct timer_list idle_timer;
171
172         struct work_struct work;
173
174         struct device   dev;
175
176         struct hci_dev  *hdev;
177         void            *l2cap_data;
178         void            *sco_data;
179         void            *priv;
180
181         struct hci_conn *link;
182 };
183
184 extern struct hci_proto *hci_proto[];
185 extern struct list_head hci_dev_list;
186 extern struct list_head hci_cb_list;
187 extern rwlock_t hci_dev_list_lock;
188 extern rwlock_t hci_cb_list_lock;
189
190 /* ----- Inquiry cache ----- */
191 #define INQUIRY_CACHE_AGE_MAX   (HZ*30)   // 30 seconds
192 #define INQUIRY_ENTRY_AGE_MAX   (HZ*60)   // 60 seconds
193
194 #define inquiry_cache_lock(c)           spin_lock(&c->lock)
195 #define inquiry_cache_unlock(c)         spin_unlock(&c->lock)
196 #define inquiry_cache_lock_bh(c)        spin_lock_bh(&c->lock)
197 #define inquiry_cache_unlock_bh(c)      spin_unlock_bh(&c->lock)
198
199 static inline void inquiry_cache_init(struct hci_dev *hdev)
200 {
201         struct inquiry_cache *c = &hdev->inq_cache;
202         spin_lock_init(&c->lock);
203         c->list = NULL;
204 }
205
206 static inline int inquiry_cache_empty(struct hci_dev *hdev)
207 {
208         struct inquiry_cache *c = &hdev->inq_cache;
209         return (c->list == NULL);
210 }
211
212 static inline long inquiry_cache_age(struct hci_dev *hdev)
213 {
214         struct inquiry_cache *c = &hdev->inq_cache;
215         return jiffies - c->timestamp;
216 }
217
218 static inline long inquiry_entry_age(struct inquiry_entry *e)
219 {
220         return jiffies - e->timestamp;
221 }
222
223 struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr);
224 void hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data);
225
226 /* ----- HCI Connections ----- */
227 enum {
228         HCI_CONN_AUTH_PEND,
229         HCI_CONN_ENCRYPT_PEND,
230         HCI_CONN_RSWITCH_PEND,
231         HCI_CONN_MODE_CHANGE_PEND,
232 };
233
234 static inline void hci_conn_hash_init(struct hci_dev *hdev)
235 {
236         struct hci_conn_hash *h = &hdev->conn_hash;
237         INIT_LIST_HEAD(&h->list);
238         spin_lock_init(&h->lock);
239         h->acl_num = 0;
240         h->sco_num = 0;
241 }
242
243 static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c)
244 {
245         struct hci_conn_hash *h = &hdev->conn_hash;
246         list_add(&c->list, &h->list);
247         if (c->type == ACL_LINK)
248                 h->acl_num++;
249         else
250                 h->sco_num++;
251 }
252
253 static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c)
254 {
255         struct hci_conn_hash *h = &hdev->conn_hash;
256         list_del(&c->list);
257         if (c->type == ACL_LINK)
258                 h->acl_num--;
259         else
260                 h->sco_num--;
261 }
262
263 static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
264                                         __u16 handle)
265 {
266         struct hci_conn_hash *h = &hdev->conn_hash;
267         struct list_head *p;
268         struct hci_conn  *c;
269
270         list_for_each(p, &h->list) {
271                 c = list_entry(p, struct hci_conn, list);
272                 if (c->handle == handle)
273                         return c;
274         }
275         return NULL;
276 }
277
278 static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
279                                         __u8 type, bdaddr_t *ba)
280 {
281         struct hci_conn_hash *h = &hdev->conn_hash;
282         struct list_head *p;
283         struct hci_conn  *c;
284
285         list_for_each(p, &h->list) {
286                 c = list_entry(p, struct hci_conn, list);
287                 if (c->type == type && !bacmp(&c->dst, ba))
288                         return c;
289         }
290         return NULL;
291 }
292
293 static inline struct hci_conn *hci_conn_hash_lookup_state(struct hci_dev *hdev,
294                                         __u8 type, __u16 state)
295 {
296         struct hci_conn_hash *h = &hdev->conn_hash;
297         struct list_head *p;
298         struct hci_conn  *c;
299
300         list_for_each(p, &h->list) {
301                 c = list_entry(p, struct hci_conn, list);
302                 if (c->type == type && c->state == state)
303                         return c;
304         }
305         return NULL;
306 }
307
308 void hci_acl_connect(struct hci_conn *conn);
309 void hci_acl_disconn(struct hci_conn *conn, __u8 reason);
310 void hci_add_sco(struct hci_conn *conn, __u16 handle);
311
312 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst);
313 int    hci_conn_del(struct hci_conn *conn);
314 void   hci_conn_hash_flush(struct hci_dev *hdev);
315
316 struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *src);
317 int hci_conn_auth(struct hci_conn *conn);
318 int hci_conn_encrypt(struct hci_conn *conn);
319 int hci_conn_change_link_key(struct hci_conn *conn);
320 int hci_conn_switch_role(struct hci_conn *conn, uint8_t role);
321
322 void hci_conn_enter_active_mode(struct hci_conn *conn);
323 void hci_conn_enter_sniff_mode(struct hci_conn *conn);
324
325 static inline void hci_conn_hold(struct hci_conn *conn)
326 {
327         atomic_inc(&conn->refcnt);
328         del_timer(&conn->disc_timer);
329 }
330
331 static inline void hci_conn_put(struct hci_conn *conn)
332 {
333         if (atomic_dec_and_test(&conn->refcnt)) {
334                 unsigned long timeo;
335                 if (conn->type == ACL_LINK) {
336                         del_timer(&conn->idle_timer);
337                         if (conn->state == BT_CONNECTED) {
338                                 timeo = msecs_to_jiffies(HCI_DISCONN_TIMEOUT);
339                                 if (!conn->out)
340                                         timeo *= 2;
341                         } else
342                                 timeo = msecs_to_jiffies(10);
343                 } else
344                         timeo = msecs_to_jiffies(10);
345                 mod_timer(&conn->disc_timer, jiffies + timeo);
346         }
347 }
348
349 /* ----- HCI tasks ----- */
350 static inline void hci_sched_cmd(struct hci_dev *hdev)
351 {
352         tasklet_schedule(&hdev->cmd_task);
353 }
354
355 static inline void hci_sched_rx(struct hci_dev *hdev)
356 {
357         tasklet_schedule(&hdev->rx_task);
358 }
359
360 static inline void hci_sched_tx(struct hci_dev *hdev)
361 {
362         tasklet_schedule(&hdev->tx_task);
363 }
364
365 /* ----- HCI Devices ----- */
366 static inline void __hci_dev_put(struct hci_dev *d)
367 {
368         if (atomic_dec_and_test(&d->refcnt))
369                 d->destruct(d);
370 }
371
372 static inline void hci_dev_put(struct hci_dev *d)
373
374         __hci_dev_put(d);
375         module_put(d->owner);
376 }
377
378 static inline struct hci_dev *__hci_dev_hold(struct hci_dev *d)
379 {
380         atomic_inc(&d->refcnt);
381         return d;
382 }
383
384 static inline struct hci_dev *hci_dev_hold(struct hci_dev *d)
385 {
386         if (try_module_get(d->owner))
387                 return __hci_dev_hold(d);
388         return NULL;
389 }
390
391 #define hci_dev_lock(d)         spin_lock(&d->lock)
392 #define hci_dev_unlock(d)       spin_unlock(&d->lock)
393 #define hci_dev_lock_bh(d)      spin_lock_bh(&d->lock)
394 #define hci_dev_unlock_bh(d)    spin_unlock_bh(&d->lock)
395
396 struct hci_dev *hci_dev_get(int index);
397 struct hci_dev *hci_get_route(bdaddr_t *src, bdaddr_t *dst);
398
399 struct hci_dev *hci_alloc_dev(void);
400 void hci_free_dev(struct hci_dev *hdev);
401 int hci_register_dev(struct hci_dev *hdev);
402 int hci_unregister_dev(struct hci_dev *hdev);
403 int hci_suspend_dev(struct hci_dev *hdev);
404 int hci_resume_dev(struct hci_dev *hdev);
405 int hci_dev_open(__u16 dev);
406 int hci_dev_close(__u16 dev);
407 int hci_dev_reset(__u16 dev);
408 int hci_dev_reset_stat(__u16 dev);
409 int hci_dev_cmd(unsigned int cmd, void __user *arg);
410 int hci_get_dev_list(void __user *arg);
411 int hci_get_dev_info(void __user *arg);
412 int hci_get_conn_list(void __user *arg);
413 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg);
414 int hci_inquiry(void __user *arg);
415
416 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb);
417
418 /* Receive frame from HCI drivers */
419 static inline int hci_recv_frame(struct sk_buff *skb)
420 {
421         struct hci_dev *hdev = (struct hci_dev *) skb->dev;
422         if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 
423                         && !test_bit(HCI_INIT, &hdev->flags))) {
424                 kfree_skb(skb);
425                 return -ENXIO;
426         }
427
428         /* Incomming skb */
429         bt_cb(skb)->incoming = 1;
430
431         /* Time stamp */
432         __net_timestamp(skb);
433
434         /* Queue frame for rx task */
435         skb_queue_tail(&hdev->rx_q, skb);
436         hci_sched_rx(hdev);
437         return 0;
438 }
439
440 int hci_register_sysfs(struct hci_dev *hdev);
441 void hci_unregister_sysfs(struct hci_dev *hdev);
442 void hci_conn_add_sysfs(struct hci_conn *conn);
443 void hci_conn_del_sysfs(struct hci_conn *conn);
444
445 #define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->parent = (pdev))
446
447 /* ----- LMP capabilities ----- */
448 #define lmp_rswitch_capable(dev)   ((dev)->features[0] & LMP_RSWITCH)
449 #define lmp_encrypt_capable(dev)   ((dev)->features[0] & LMP_ENCRYPT)
450 #define lmp_sniff_capable(dev)     ((dev)->features[0] & LMP_SNIFF)
451 #define lmp_sniffsubr_capable(dev) ((dev)->features[5] & LMP_SNIFF_SUBR)
452
453 /* ----- HCI protocols ----- */
454 struct hci_proto {
455         char            *name;
456         unsigned int    id;
457         unsigned long   flags;
458
459         void            *priv;
460
461         int (*connect_ind)      (struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type);
462         int (*connect_cfm)      (struct hci_conn *conn, __u8 status);
463         int (*disconn_ind)      (struct hci_conn *conn, __u8 reason);
464         int (*recv_acldata)     (struct hci_conn *conn, struct sk_buff *skb, __u16 flags);
465         int (*recv_scodata)     (struct hci_conn *conn, struct sk_buff *skb);
466         int (*auth_cfm)         (struct hci_conn *conn, __u8 status);
467         int (*encrypt_cfm)      (struct hci_conn *conn, __u8 status);
468 };
469
470 static inline int hci_proto_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
471 {
472         register struct hci_proto *hp;
473         int mask = 0;
474         
475         hp = hci_proto[HCI_PROTO_L2CAP];
476         if (hp && hp->connect_ind)
477                 mask |= hp->connect_ind(hdev, bdaddr, type);
478
479         hp = hci_proto[HCI_PROTO_SCO];
480         if (hp && hp->connect_ind)
481                 mask |= hp->connect_ind(hdev, bdaddr, type);
482
483         return mask;
484 }
485
486 static inline void hci_proto_connect_cfm(struct hci_conn *conn, __u8 status)
487 {
488         register struct hci_proto *hp;
489
490         hp = hci_proto[HCI_PROTO_L2CAP];
491         if (hp && hp->connect_cfm)
492                 hp->connect_cfm(conn, status);
493
494         hp = hci_proto[HCI_PROTO_SCO];
495         if (hp && hp->connect_cfm)
496                 hp->connect_cfm(conn, status);
497 }
498
499 static inline void hci_proto_disconn_ind(struct hci_conn *conn, __u8 reason)
500 {
501         register struct hci_proto *hp;
502
503         hp = hci_proto[HCI_PROTO_L2CAP];
504         if (hp && hp->disconn_ind)
505                 hp->disconn_ind(conn, reason);
506
507         hp = hci_proto[HCI_PROTO_SCO];
508         if (hp && hp->disconn_ind)
509                 hp->disconn_ind(conn, reason);
510 }
511
512 static inline void hci_proto_auth_cfm(struct hci_conn *conn, __u8 status)
513 {
514         register struct hci_proto *hp;
515
516         hp = hci_proto[HCI_PROTO_L2CAP];
517         if (hp && hp->auth_cfm)
518                 hp->auth_cfm(conn, status);
519
520         hp = hci_proto[HCI_PROTO_SCO];
521         if (hp && hp->auth_cfm)
522                 hp->auth_cfm(conn, status);
523 }
524
525 static inline void hci_proto_encrypt_cfm(struct hci_conn *conn, __u8 status)
526 {
527         register struct hci_proto *hp;
528
529         hp = hci_proto[HCI_PROTO_L2CAP];
530         if (hp && hp->encrypt_cfm)
531                 hp->encrypt_cfm(conn, status);
532
533         hp = hci_proto[HCI_PROTO_SCO];
534         if (hp && hp->encrypt_cfm)
535                 hp->encrypt_cfm(conn, status);
536 }
537
538 int hci_register_proto(struct hci_proto *hproto);
539 int hci_unregister_proto(struct hci_proto *hproto);
540
541 /* ----- HCI callbacks ----- */
542 struct hci_cb {
543         struct list_head list;
544
545         char *name;
546
547         void (*auth_cfm)        (struct hci_conn *conn, __u8 status);
548         void (*encrypt_cfm)     (struct hci_conn *conn, __u8 status, __u8 encrypt);
549         void (*key_change_cfm)  (struct hci_conn *conn, __u8 status);
550         void (*role_switch_cfm) (struct hci_conn *conn, __u8 status, __u8 role);
551 };
552
553 static inline void hci_auth_cfm(struct hci_conn *conn, __u8 status)
554 {
555         struct list_head *p;
556
557         hci_proto_auth_cfm(conn, status);
558
559         read_lock_bh(&hci_cb_list_lock);
560         list_for_each(p, &hci_cb_list) {
561                 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
562                 if (cb->auth_cfm)
563                         cb->auth_cfm(conn, status);
564         }
565         read_unlock_bh(&hci_cb_list_lock);
566 }
567
568 static inline void hci_encrypt_cfm(struct hci_conn *conn, __u8 status, __u8 encrypt)
569 {
570         struct list_head *p;
571
572         hci_proto_encrypt_cfm(conn, status);
573
574         read_lock_bh(&hci_cb_list_lock);
575         list_for_each(p, &hci_cb_list) {
576                 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
577                 if (cb->encrypt_cfm)
578                         cb->encrypt_cfm(conn, status, encrypt);
579         }
580         read_unlock_bh(&hci_cb_list_lock);
581 }
582
583 static inline void hci_key_change_cfm(struct hci_conn *conn, __u8 status)
584 {
585         struct list_head *p;
586
587         read_lock_bh(&hci_cb_list_lock);
588         list_for_each(p, &hci_cb_list) {
589                 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
590                 if (cb->key_change_cfm)
591                         cb->key_change_cfm(conn, status);
592         }
593         read_unlock_bh(&hci_cb_list_lock);
594 }
595
596 static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status, __u8 role)
597 {
598         struct list_head *p;
599
600         read_lock_bh(&hci_cb_list_lock);
601         list_for_each(p, &hci_cb_list) {
602                 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
603                 if (cb->role_switch_cfm)
604                         cb->role_switch_cfm(conn, status, role);
605         }
606         read_unlock_bh(&hci_cb_list_lock);
607 }
608
609 int hci_register_cb(struct hci_cb *hcb);
610 int hci_unregister_cb(struct hci_cb *hcb);
611
612 int hci_register_notifier(struct notifier_block *nb);
613 int hci_unregister_notifier(struct notifier_block *nb);
614
615 int hci_send_cmd(struct hci_dev *hdev, __u16 ogf, __u16 ocf, __u32 plen, void *param);
616 int hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags);
617 int hci_send_sco(struct hci_conn *conn, struct sk_buff *skb);
618
619 void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 ogf, __u16 ocf);
620
621 void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data);
622
623 /* ----- HCI Sockets ----- */
624 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb);
625
626 /* HCI info for socket */
627 #define hci_pi(sk) ((struct hci_pinfo *) sk)
628
629 struct hci_pinfo {
630         struct bt_sock    bt;
631         struct hci_dev    *hdev;
632         struct hci_filter filter;
633         __u32             cmsg_mask;
634 };
635
636 /* HCI security filter */
637 #define HCI_SFLT_MAX_OGF  5
638
639 struct hci_sec_filter {
640         __u32 type_mask;
641         __u32 event_mask[2];
642         __u32 ocf_mask[HCI_SFLT_MAX_OGF + 1][4];
643 };
644
645 /* ----- HCI requests ----- */
646 #define HCI_REQ_DONE      0
647 #define HCI_REQ_PEND      1
648 #define HCI_REQ_CANCELED  2
649
650 #define hci_req_lock(d)         down(&d->req_lock)
651 #define hci_req_unlock(d)       up(&d->req_lock)
652
653 void hci_req_complete(struct hci_dev *hdev, int result);
654
655 #endif /* __HCI_CORE_H */