3 Broadcom B43 wireless driver
5 Transmission (TX/RX) related functions.
7 Copyright (C) 2005 Martin Langer <martin-langer@gmx.de>
8 Copyright (C) 2005 Stefano Brivio <stefano.brivio@polimi.it>
9 Copyright (C) 2005, 2006 Michael Buesch <mb@bu3sch.de>
10 Copyright (C) 2005 Danny van Dyk <kugelfang@gentoo.org>
11 Copyright (C) 2005 Andreas Jaggi <andreas.jaggi@waterwave.ch>
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with this program; see the file COPYING. If not, write to
25 the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
26 Boston, MA 02110-1301, USA.
35 /* Extract the bitrate out of a CCK PLCP header. */
36 static u8
b43_plcp_get_bitrate_cck(struct b43_plcp_hdr6
*plcp
)
38 switch (plcp
->raw
[0]) {
40 return B43_CCK_RATE_1MB
;
42 return B43_CCK_RATE_2MB
;
44 return B43_CCK_RATE_5MB
;
46 return B43_CCK_RATE_11MB
;
52 /* Extract the bitrate out of an OFDM PLCP header. */
53 static u8
b43_plcp_get_bitrate_ofdm(struct b43_plcp_hdr6
*plcp
)
55 switch (plcp
->raw
[0] & 0xF) {
57 return B43_OFDM_RATE_6MB
;
59 return B43_OFDM_RATE_9MB
;
61 return B43_OFDM_RATE_12MB
;
63 return B43_OFDM_RATE_18MB
;
65 return B43_OFDM_RATE_24MB
;
67 return B43_OFDM_RATE_36MB
;
69 return B43_OFDM_RATE_48MB
;
71 return B43_OFDM_RATE_54MB
;
77 u8
b43_plcp_get_ratecode_cck(const u8 bitrate
)
80 case B43_CCK_RATE_1MB
:
82 case B43_CCK_RATE_2MB
:
84 case B43_CCK_RATE_5MB
:
86 case B43_CCK_RATE_11MB
:
93 u8
b43_plcp_get_ratecode_ofdm(const u8 bitrate
)
96 case B43_OFDM_RATE_6MB
:
98 case B43_OFDM_RATE_9MB
:
100 case B43_OFDM_RATE_12MB
:
102 case B43_OFDM_RATE_18MB
:
104 case B43_OFDM_RATE_24MB
:
106 case B43_OFDM_RATE_36MB
:
108 case B43_OFDM_RATE_48MB
:
110 case B43_OFDM_RATE_54MB
:
117 void b43_generate_plcp_hdr(struct b43_plcp_hdr4
*plcp
,
118 const u16 octets
, const u8 bitrate
)
120 __le32
*data
= &(plcp
->data
);
121 __u8
*raw
= plcp
->raw
;
123 if (b43_is_ofdm_rate(bitrate
)) {
126 d
= b43_plcp_get_ratecode_ofdm(bitrate
);
127 B43_WARN_ON(octets
& 0xF000);
129 *data
= cpu_to_le32(d
);
133 plen
= octets
* 16 / bitrate
;
134 if ((octets
* 16 % bitrate
) > 0) {
136 if ((bitrate
== B43_CCK_RATE_11MB
)
137 && ((octets
* 8 % 11) < 4)) {
143 *data
|= cpu_to_le32(plen
<< 16);
144 raw
[0] = b43_plcp_get_ratecode_cck(bitrate
);
148 static u8
b43_calc_fallback_rate(u8 bitrate
)
151 case B43_CCK_RATE_1MB
:
152 return B43_CCK_RATE_1MB
;
153 case B43_CCK_RATE_2MB
:
154 return B43_CCK_RATE_1MB
;
155 case B43_CCK_RATE_5MB
:
156 return B43_CCK_RATE_2MB
;
157 case B43_CCK_RATE_11MB
:
158 return B43_CCK_RATE_5MB
;
159 case B43_OFDM_RATE_6MB
:
160 return B43_CCK_RATE_5MB
;
161 case B43_OFDM_RATE_9MB
:
162 return B43_OFDM_RATE_6MB
;
163 case B43_OFDM_RATE_12MB
:
164 return B43_OFDM_RATE_9MB
;
165 case B43_OFDM_RATE_18MB
:
166 return B43_OFDM_RATE_12MB
;
167 case B43_OFDM_RATE_24MB
:
168 return B43_OFDM_RATE_18MB
;
169 case B43_OFDM_RATE_36MB
:
170 return B43_OFDM_RATE_24MB
;
171 case B43_OFDM_RATE_48MB
:
172 return B43_OFDM_RATE_36MB
;
173 case B43_OFDM_RATE_54MB
:
174 return B43_OFDM_RATE_48MB
;
180 /* Generate a TX data header. */
181 void b43_generate_txhdr(struct b43_wldev
*dev
,
183 const unsigned char *fragment_data
,
184 unsigned int fragment_len
,
185 const struct ieee80211_tx_control
*txctl
,
188 struct b43_txhdr
*txhdr
= (struct b43_txhdr
*)_txhdr
;
189 const struct b43_phy
*phy
= &dev
->phy
;
190 const struct ieee80211_hdr
*wlhdr
=
191 (const struct ieee80211_hdr
*)fragment_data
;
192 int use_encryption
= (!(txctl
->flags
& IEEE80211_TXCTL_DO_NOT_ENCRYPT
));
193 u16 fctl
= le16_to_cpu(wlhdr
->frame_control
);
195 int rate_ofdm
, rate_fb_ofdm
;
196 unsigned int plcp_fragment_len
;
201 memset(txhdr
, 0, sizeof(*txhdr
));
203 rate
= txctl
->tx_rate
;
204 rate_ofdm
= b43_is_ofdm_rate(rate
);
205 rate_fb
= (txctl
->alt_retry_rate
== -1) ? rate
: txctl
->alt_retry_rate
;
206 rate_fb_ofdm
= b43_is_ofdm_rate(rate_fb
);
209 txhdr
->phy_rate
= b43_plcp_get_ratecode_ofdm(rate
);
211 txhdr
->phy_rate
= b43_plcp_get_ratecode_cck(rate
);
212 txhdr
->mac_frame_ctl
= wlhdr
->frame_control
;
213 memcpy(txhdr
->tx_receiver
, wlhdr
->addr1
, 6);
215 /* Calculate duration for fallback rate */
216 if ((rate_fb
== rate
) ||
217 (wlhdr
->duration_id
& cpu_to_le16(0x8000)) ||
218 (wlhdr
->duration_id
== cpu_to_le16(0))) {
219 /* If the fallback rate equals the normal rate or the
220 * dur_id field contains an AID, CFP magic or 0,
221 * use the original dur_id field. */
222 txhdr
->dur_fb
= wlhdr
->duration_id
;
224 int fbrate_base100kbps
= B43_RATE_TO_BASE100KBPS(rate_fb
);
225 txhdr
->dur_fb
= ieee80211_generic_frame_duration(dev
->wl
->hw
,
231 plcp_fragment_len
= fragment_len
+ FCS_LEN
;
232 if (use_encryption
) {
233 u8 key_idx
= (u16
) (txctl
->key_idx
);
238 B43_WARN_ON(key_idx
>= dev
->max_nr_keys
);
239 key
= &(dev
->key
[key_idx
]);
241 if (likely(key
->keyconf
)) {
242 /* This key is valid. Use it for encryption. */
244 /* Hardware appends ICV. */
245 plcp_fragment_len
+= txctl
->icv_len
;
247 key_idx
= b43_kidx_to_fw(dev
, key_idx
);
248 mac_ctl
|= (key_idx
<< B43_TXH_MAC_KEYIDX_SHIFT
) &
250 mac_ctl
|= (key
->algorithm
<< B43_TXH_MAC_KEYALG_SHIFT
) &
252 wlhdr_len
= ieee80211_get_hdrlen(fctl
);
253 iv_len
= min((size_t) txctl
->iv_len
,
254 ARRAY_SIZE(txhdr
->iv
));
255 memcpy(txhdr
->iv
, ((u8
*) wlhdr
) + wlhdr_len
, iv_len
);
258 if (b43_is_old_txhdr_format(dev
)) {
259 b43_generate_plcp_hdr((struct b43_plcp_hdr4
*)(&txhdr
->old_format
.plcp
),
260 plcp_fragment_len
, rate
);
262 b43_generate_plcp_hdr((struct b43_plcp_hdr4
*)(&txhdr
->new_format
.plcp
),
263 plcp_fragment_len
, rate
);
265 b43_generate_plcp_hdr((struct b43_plcp_hdr4
*)(&txhdr
->plcp_fb
),
266 plcp_fragment_len
, rate_fb
);
268 /* Extra Frame Types */
270 extra_ft
|= B43_TXH_EFT_FB_OFDM
;
272 extra_ft
|= B43_TXH_EFT_FB_CCK
;
274 /* Set channel radio code. Note that the micrcode ORs 0x100 to
275 * this value before comparing it to the value in SHM, if this
278 txhdr
->chan_radio_code
= phy
->channel
;
280 /* PHY TX Control word */
282 phy_ctl
|= B43_TXH_PHY_ENC_OFDM
;
284 phy_ctl
|= B43_TXH_PHY_ENC_CCK
;
285 if (dev
->short_preamble
)
286 phy_ctl
|= B43_TXH_PHY_SHORTPRMBL
;
288 switch (b43_ieee80211_antenna_sanitize(dev
, txctl
->antenna_sel_tx
)) {
289 case 0: /* Default */
290 phy_ctl
|= B43_TXH_PHY_ANT01AUTO
;
292 case 1: /* Antenna 0 */
293 phy_ctl
|= B43_TXH_PHY_ANT0
;
295 case 2: /* Antenna 1 */
296 phy_ctl
|= B43_TXH_PHY_ANT1
;
298 case 3: /* Antenna 2 */
299 phy_ctl
|= B43_TXH_PHY_ANT2
;
301 case 4: /* Antenna 3 */
302 phy_ctl
|= B43_TXH_PHY_ANT3
;
309 if (!(txctl
->flags
& IEEE80211_TXCTL_NO_ACK
))
310 mac_ctl
|= B43_TXH_MAC_ACK
;
311 if (!(((fctl
& IEEE80211_FCTL_FTYPE
) == IEEE80211_FTYPE_CTL
) &&
312 ((fctl
& IEEE80211_FCTL_STYPE
) == IEEE80211_STYPE_PSPOLL
)))
313 mac_ctl
|= B43_TXH_MAC_HWSEQ
;
314 if (txctl
->flags
& IEEE80211_TXCTL_FIRST_FRAGMENT
)
315 mac_ctl
|= B43_TXH_MAC_STMSDU
;
316 if (phy
->type
== B43_PHYTYPE_A
)
317 mac_ctl
|= B43_TXH_MAC_5GHZ
;
318 if (txctl
->flags
& IEEE80211_TXCTL_LONG_RETRY_LIMIT
)
319 mac_ctl
|= B43_TXH_MAC_LONGFRAME
;
321 /* Generate the RTS or CTS-to-self frame */
322 if ((txctl
->flags
& IEEE80211_TXCTL_USE_RTS_CTS
) ||
323 (txctl
->flags
& IEEE80211_TXCTL_USE_CTS_PROTECT
)) {
325 struct ieee80211_hdr
*hdr
;
326 int rts_rate
, rts_rate_fb
;
327 int rts_rate_ofdm
, rts_rate_fb_ofdm
;
328 struct b43_plcp_hdr6
*plcp
;
330 rts_rate
= txctl
->rts_cts_rate
;
331 rts_rate_ofdm
= b43_is_ofdm_rate(rts_rate
);
332 rts_rate_fb
= b43_calc_fallback_rate(rts_rate
);
333 rts_rate_fb_ofdm
= b43_is_ofdm_rate(rts_rate_fb
);
335 if (txctl
->flags
& IEEE80211_TXCTL_USE_CTS_PROTECT
) {
336 struct ieee80211_cts
*cts
;
338 if (b43_is_old_txhdr_format(dev
)) {
339 cts
= (struct ieee80211_cts
*)
340 (txhdr
->old_format
.rts_frame
);
342 cts
= (struct ieee80211_cts
*)
343 (txhdr
->new_format
.rts_frame
);
345 ieee80211_ctstoself_get(dev
->wl
->hw
, txctl
->vif
,
346 fragment_data
, fragment_len
,
348 mac_ctl
|= B43_TXH_MAC_SENDCTS
;
349 len
= sizeof(struct ieee80211_cts
);
351 struct ieee80211_rts
*rts
;
353 if (b43_is_old_txhdr_format(dev
)) {
354 rts
= (struct ieee80211_rts
*)
355 (txhdr
->old_format
.rts_frame
);
357 rts
= (struct ieee80211_rts
*)
358 (txhdr
->new_format
.rts_frame
);
360 ieee80211_rts_get(dev
->wl
->hw
, txctl
->vif
,
361 fragment_data
, fragment_len
,
363 mac_ctl
|= B43_TXH_MAC_SENDRTS
;
364 len
= sizeof(struct ieee80211_rts
);
368 /* Generate the PLCP headers for the RTS/CTS frame */
369 if (b43_is_old_txhdr_format(dev
))
370 plcp
= &txhdr
->old_format
.rts_plcp
;
372 plcp
= &txhdr
->new_format
.rts_plcp
;
373 b43_generate_plcp_hdr((struct b43_plcp_hdr4
*)plcp
,
375 plcp
= &txhdr
->rts_plcp_fb
;
376 b43_generate_plcp_hdr((struct b43_plcp_hdr4
*)plcp
,
379 if (b43_is_old_txhdr_format(dev
)) {
380 hdr
= (struct ieee80211_hdr
*)
381 (&txhdr
->old_format
.rts_frame
);
383 hdr
= (struct ieee80211_hdr
*)
384 (&txhdr
->new_format
.rts_frame
);
386 txhdr
->rts_dur_fb
= hdr
->duration_id
;
389 extra_ft
|= B43_TXH_EFT_RTS_OFDM
;
390 txhdr
->phy_rate_rts
=
391 b43_plcp_get_ratecode_ofdm(rts_rate
);
393 extra_ft
|= B43_TXH_EFT_RTS_CCK
;
394 txhdr
->phy_rate_rts
=
395 b43_plcp_get_ratecode_cck(rts_rate
);
397 if (rts_rate_fb_ofdm
)
398 extra_ft
|= B43_TXH_EFT_RTSFB_OFDM
;
400 extra_ft
|= B43_TXH_EFT_RTSFB_CCK
;
404 if (b43_is_old_txhdr_format(dev
))
405 txhdr
->old_format
.cookie
= cpu_to_le16(cookie
);
407 txhdr
->new_format
.cookie
= cpu_to_le16(cookie
);
409 /* Apply the bitfields */
410 txhdr
->mac_ctl
= cpu_to_le32(mac_ctl
);
411 txhdr
->phy_ctl
= cpu_to_le16(phy_ctl
);
412 txhdr
->extra_ft
= extra_ft
;
416 static s8
b43_rssi_postprocess(struct b43_wldev
*dev
,
417 u8 in_rssi
, int ofdm
,
418 int adjust_2053
, int adjust_2050
)
420 struct b43_phy
*phy
= &dev
->phy
;
423 switch (phy
->radio_ver
) {
436 if (dev
->dev
->bus
->sprom
.
437 boardflags_lo
& B43_BFL_RSSI
) {
440 tmp
= phy
->nrssi_lt
[in_rssi
];
452 if (phy
->type
== B43_PHYTYPE_G
&& adjust_2050
)
478 static s8
b43_rssinoise_postprocess(struct b43_wldev
*dev
, u8 in_rssi
)
480 struct b43_phy
*phy
= &dev
->phy
;
483 if (phy
->type
== B43_PHYTYPE_A
) {
484 //TODO: Incomplete specs.
487 ret
= b43_rssi_postprocess(dev
, in_rssi
, 0, 1, 1);
493 void b43_rx(struct b43_wldev
*dev
, struct sk_buff
*skb
, const void *_rxhdr
)
495 struct ieee80211_rx_status status
;
496 struct b43_plcp_hdr6
*plcp
;
497 struct ieee80211_hdr
*wlhdr
;
498 const struct b43_rxhdr_fw4
*rxhdr
= _rxhdr
;
500 u16 phystat0
, phystat3
, chanstat
, mactime
;
506 memset(&status
, 0, sizeof(status
));
508 /* Get metadata about the frame from the header. */
509 phystat0
= le16_to_cpu(rxhdr
->phy_status0
);
510 phystat3
= le16_to_cpu(rxhdr
->phy_status3
);
512 macstat
= le32_to_cpu(rxhdr
->mac_status
);
513 mactime
= le16_to_cpu(rxhdr
->mac_time
);
514 chanstat
= le16_to_cpu(rxhdr
->channel
);
516 if (macstat
& B43_RX_MAC_FCSERR
)
517 dev
->wl
->ieee_stats
.dot11FCSErrorCount
++;
518 if (macstat
& B43_RX_MAC_DECERR
) {
519 /* Decryption with the given key failed.
520 * Drop the packet. We also won't be able to decrypt it with
521 * the key in software. */
525 /* Skip PLCP and padding */
526 padding
= (macstat
& B43_RX_MAC_PADDING
) ? 2 : 0;
527 if (unlikely(skb
->len
< (sizeof(struct b43_plcp_hdr6
) + padding
))) {
528 b43dbg(dev
->wl
, "RX: Packet size underrun (1)\n");
531 plcp
= (struct b43_plcp_hdr6
*)(skb
->data
+ padding
);
532 skb_pull(skb
, sizeof(struct b43_plcp_hdr6
) + padding
);
533 /* The skb contains the Wireless Header + payload data now */
534 if (unlikely(skb
->len
< (2 + 2 + 6 /*minimum hdr */ + FCS_LEN
))) {
535 b43dbg(dev
->wl
, "RX: Packet size underrun (2)\n");
538 wlhdr
= (struct ieee80211_hdr
*)(skb
->data
);
539 fctl
= le16_to_cpu(wlhdr
->frame_control
);
541 if (macstat
& B43_RX_MAC_DEC
) {
545 keyidx
= ((macstat
& B43_RX_MAC_KEYIDX
)
546 >> B43_RX_MAC_KEYIDX_SHIFT
);
547 /* We must adjust the key index here. We want the "physical"
548 * key index, but the ucode passed it slightly different.
550 keyidx
= b43_kidx_to_raw(dev
, keyidx
);
551 B43_WARN_ON(keyidx
>= dev
->max_nr_keys
);
553 if (dev
->key
[keyidx
].algorithm
!= B43_SEC_ALGO_NONE
) {
554 wlhdr_len
= ieee80211_get_hdrlen(fctl
);
555 if (unlikely(skb
->len
< (wlhdr_len
+ 3))) {
557 "RX: Packet size underrun (3)\n");
560 status
.flag
|= RX_FLAG_DECRYPTED
;
564 status
.ssi
= b43_rssi_postprocess(dev
, jssi
,
565 (phystat0
& B43_RX_PHYST0_OFDM
),
566 (phystat0
& B43_RX_PHYST0_GAINCTL
),
567 (phystat3
& B43_RX_PHYST3_TRSTATE
));
568 status
.noise
= dev
->stats
.link_noise
;
569 /* the next line looks wrong, but is what mac80211 wants */
570 status
.signal
= (jssi
* 100) / B43_RX_MAX_SSI
;
571 if (phystat0
& B43_RX_PHYST0_OFDM
)
572 status
.rate
= b43_plcp_get_bitrate_ofdm(plcp
);
574 status
.rate
= b43_plcp_get_bitrate_cck(plcp
);
575 status
.antenna
= !!(phystat0
& B43_RX_PHYST0_ANT
);
578 * If monitors are present get full 64-bit timestamp. This
579 * code assumes we get to process the packet within 16 bits
580 * of timestamp, i.e. about 65 milliseconds after the PHY
581 * received the first symbol.
583 if (dev
->wl
->radiotap_enabled
) {
586 b43_tsf_read(dev
, &status
.mactime
);
587 low_mactime_now
= status
.mactime
;
588 status
.mactime
= status
.mactime
& ~0xFFFFULL
;
589 status
.mactime
+= mactime
;
590 if (low_mactime_now
<= mactime
)
591 status
.mactime
-= 0x10000;
592 status
.flag
|= RX_FLAG_TSFT
;
595 chanid
= (chanstat
& B43_RX_CHAN_ID
) >> B43_RX_CHAN_ID_SHIFT
;
596 switch (chanstat
& B43_RX_CHAN_PHYTYPE
) {
598 status
.phymode
= MODE_IEEE80211A
;
600 /* FIXME: We don't really know which value the "chanid" contains.
601 * So the following assignment might be wrong. */
602 status
.channel
= chanid
;
603 status
.freq
= b43_channel_to_freq_5ghz(status
.channel
);
606 status
.phymode
= MODE_IEEE80211G
;
607 /* chanid is the radio channel cookie value as used
608 * to tune the radio. */
609 status
.freq
= chanid
+ 2400;
610 status
.channel
= b43_freq_to_channel_2ghz(status
.freq
);
613 status
.phymode
= 0xDEAD /*FIXME MODE_IEEE80211N*/;
614 /* chanid is the SHM channel cookie. Which is the plain
615 * channel number in b43. */
616 status
.channel
= chanid
;
617 if (chanstat
& B43_RX_CHAN_5GHZ
)
618 status
.freq
= b43_freq_to_channel_5ghz(status
.freq
);
620 status
.freq
= b43_freq_to_channel_2ghz(status
.freq
);
627 dev
->stats
.last_rx
= jiffies
;
628 ieee80211_rx_irqsafe(dev
->wl
->hw
, skb
, &status
);
632 b43dbg(dev
->wl
, "RX: Packet dropped\n");
633 dev_kfree_skb_any(skb
);
636 void b43_handle_txstatus(struct b43_wldev
*dev
,
637 const struct b43_txstatus
*status
)
639 b43_debugfs_log_txstat(dev
, status
);
641 if (status
->intermediate
)
643 if (status
->for_ampdu
)
646 dev
->wl
->ieee_stats
.dot11ACKFailureCount
++;
647 if (status
->rts_count
) {
648 if (status
->rts_count
== 0xF) //FIXME
649 dev
->wl
->ieee_stats
.dot11RTSFailureCount
++;
651 dev
->wl
->ieee_stats
.dot11RTSSuccessCount
++;
654 b43_dma_handle_txstatus(dev
, status
);
657 /* Handle TX status report as received through DMA/PIO queues */
658 void b43_handle_hwtxstatus(struct b43_wldev
*dev
,
659 const struct b43_hwtxstatus
*hw
)
661 struct b43_txstatus status
;
664 status
.cookie
= le16_to_cpu(hw
->cookie
);
665 status
.seq
= le16_to_cpu(hw
->seq
);
666 status
.phy_stat
= hw
->phy_stat
;
668 status
.frame_count
= (tmp
>> 4);
669 status
.rts_count
= (tmp
& 0x0F);
671 status
.supp_reason
= ((tmp
& 0x1C) >> 2);
672 status
.pm_indicated
= !!(tmp
& 0x80);
673 status
.intermediate
= !!(tmp
& 0x40);
674 status
.for_ampdu
= !!(tmp
& 0x20);
675 status
.acked
= !!(tmp
& 0x02);
677 b43_handle_txstatus(dev
, &status
);
680 /* Stop any TX operation on the device (suspend the hardware queues) */
681 void b43_tx_suspend(struct b43_wldev
*dev
)
683 b43_dma_tx_suspend(dev
);
686 /* Resume any TX operation on the device (resume the hardware queues) */
687 void b43_tx_resume(struct b43_wldev
*dev
)
689 b43_dma_tx_resume(dev
);
693 static void upload_qos_parms(struct b43_wldev
*dev
,
694 const u16
* parms
, u16 offset
)
698 for (i
= 0; i
< B43_NR_QOSPARMS
; i
++) {
699 b43_shm_write16(dev
, B43_SHM_SHARED
,
700 offset
+ (i
* 2), parms
[i
]);
705 /* Initialize the QoS parameters */
706 void b43_qos_init(struct b43_wldev
*dev
)
708 /* FIXME: This function must probably be called from the mac80211
709 * config callback. */
712 b43_hf_write(dev
, b43_hf_read(dev
) | B43_HF_EDCF
);
714 b43_write16(dev
, 0x688, b43_read16(dev
, 0x688) | 0x4);
716 /*TODO: We might need some stack support here to get the values. */