aboutsummaryrefslogtreecommitdiffstats
path: root/os/hal/src/mac.c
blob: 62340dc31a04286653d2f40f738420f6c98fa834 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
/*
    ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010 Giovanni Di Sirio.

    This file is part of ChibiOS/RT.

    ChibiOS/RT 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 3 of the License, or
    (at your option) any later version.

    ChibiOS/RT 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, see <http://www.gnu.org/licenses/>.
*/

/**
 * @file    mac.c
 * @brief   MAC Driver code.
 *
 * @addtogroup MAC
 * @{
 */

#include "ch.h"
#include "hal.h"

#if CH_HAL_USE_MAC || defined(__DOXYGEN__)

/*===========================================================================*/
/* Driver exported variables.                                                */
/*===========================================================================*/

/*===========================================================================*/
/* Driver local variables.                                                   */
/*===========================================================================*/

/*===========================================================================*/
/* Driver local functions.                                                   */
/*===========================================================================*/

/*===========================================================================*/
/* Driver interrupt handlers.                                                */
/*===========================================================================*/

/*===========================================================================*/
/* Driver exported functions.                                                */
/*===========================================================================*/

/**
 * @brief   MAC Driver initialization.
 *
 * @init
 */
void macInit(void) {

  mac_lld_init();
}

/**
 * @brief   Initialize the standard part of a @p MACDriver structure.
 *
 * @param[in] macp      pointer to the @p MACDriver object
 *
 * @init
 */
void macObjectInit(MACDriver *macp) {

  chSemInit(&macp->md_tdsem, 0);
  chSemInit(&macp->md_rdsem, 0);
#if CH_USE_EVENTS
  chEvtInit(&macp->md_rdevent);
#endif
}

/**
 * @brief   MAC address setup.
 * @pre     This function must be invoked with the driver in the stopped
 *          state. If invoked on an active interface then it is ignored.
 *
 * @param[in] macp      pointer to the @p MACDriver object
 * @param[in] p         pointer to a six bytes buffer containing the MAC
 *                      address. If this parameter is set to @p NULL then MAC
 *                      a system default is used.
 *
 * @api
 */
void macSetAddress(MACDriver *macp, const uint8_t *p) {

  mac_lld_set_address(macp, p);
}

/**
 * @brief   Allocates a transmission descriptor.
 * @details One of the available transmission descriptors is locked and
 *          returned. If a descriptor is not currently available then the
 *          invoking thread is queued until one is freed.
 *
 * @param[in] macp      pointer to the @p MACDriver object
 * @param[out] tdp      pointer to a @p MACTransmitDescriptor structure
 * @param[in] time      the number of ticks before the operation timeouts,
 *                      the following special values are allowed:
 *                      - @a TIME_IMMEDIATE immediate timeout.
 *                      - @a TIME_INFINITE no timeout.
 *                      .
 * @return              The operation status.
 * @retval RDY_OK       the descriptor was obtained.
 * @retval RDY_TIMEOUT  the operation timed out, descriptor not initialized.
 *
 * @api
 */
msg_t macWaitTransmitDescriptor(MACDriver *macp,
                                MACTransmitDescriptor *tdp,
                                systime_t time) {
  msg_t msg;

  while (((msg = max_lld_get_transmit_descriptor(macp, tdp)) != RDY_OK) &&
         (time > 0)) {
    chSysLock();
    systime_t now = chTimeNow();
    if ((msg = chSemWaitTimeoutS(&macp->md_tdsem, time)) == RDY_TIMEOUT)
      break;
    if (time != TIME_INFINITE)
      time -= (chTimeNow() - now);
    chSysUnlock();
  }
  return msg;
}

/**
 * @brief   Releases a transmit descriptor and starts the transmission of the
 *          enqueued data as a single frame.
 *
 * @param[in] tdp       the pointer to the @p MACTransmitDescriptor structure
 *
 * @api
 */
void macReleaseTransmitDescriptor(MACTransmitDescriptor *tdp) {

  mac_lld_release_transmit_descriptor(tdp);
}

/**
 * @brief   Waits for a received frame.
 * @details Stops until a frame is received and buffered. If a frame is
 *          not immediately available then the invoking thread is queued
 *          until one is received.
 *
 * @param[in] macp      pointer to the @p MACDriver object
 * @param[out] rdp      pointer to a @p MACReceiveDescriptor structure
 * @param[in] time      the number of ticks before the operation timeouts,
 *                      the following special values are allowed:
 *                      - @a TIME_IMMEDIATE immediate timeout.
 *                      - @a TIME_INFINITE no timeout.
 *                      .
 * @return              The operation status.
 * @retval RDY_OK       the descriptor was obtained.
 * @retval RDY_TIMEOUT  the operation timed out, descriptor not initialized.
 *
 * @api
 */
msg_t macWaitReceiveDescriptor(MACDriver *macp,
                               MACReceiveDescriptor *rdp,
                               systime_t time) {
  msg_t msg;

  while (((msg = max_lld_get_receive_descriptor(macp, rdp)) != RDY_OK) &&
         (time > 0)) {
    chSysLock();
    systime_t now = chTimeNow();
    if ((msg = chSemWaitTimeoutS(&macp->md_rdsem, time)) == RDY_TIMEOUT)
      break;
    if (time != TIME_INFINITE)
      time -= (chTimeNow() - now);
    chSysUnlock();
  }
  return msg;
}

/**
 * @brief   Releases a receive descriptor.
 * @details The descriptor and its buffer are made available for more incoming
 *          frames.
 *
 * @param[in] rdp       the pointer to the @p MACReceiveDescriptor structure
 *
 * @api
 */
void macReleaseReceiveDescriptor(MACReceiveDescriptor *rdp) {

  mac_lld_release_receive_descriptor(rdp);
}

/**
 * @brief   Updates and returns the link status.
 *
 * @param[in] macp      pointer to the @p MACDriver object
 * @return              The link status.
 * @retval TRUE         if the link is active.
 * @retval FALSE        if the link is down.
 *
 * @api
 */
bool_t macPollLinkStatus(MACDriver *macp) {

  return mac_lld_poll_link_status(macp);
}

#endif /* CH_HAL_USE_MAC */

/** @} */
return 0; } static int macio_do_delay(PMF_STD_ARGS, u32 duration) { /* assume we can sleep ! */ msleep((duration + 999) / 1000); return 0; } static struct pmf_handlers macio_gpio_handlers = { .irq_enable = macio_do_gpio_irq_enable, .irq_disable = macio_do_gpio_irq_disable, .write_gpio = macio_do_gpio_write, .read_gpio = macio_do_gpio_read, .delay = macio_do_delay, }; static void macio_gpio_init_one(struct macio_chip *macio) { struct device_node *gparent, *gp; /* * Find the "gpio" parent node */ for (gparent = NULL; (gparent = of_get_next_child(macio->of_node, gparent)) != NULL;) if (strcmp(gparent->name, "gpio") == 0) break; if (gparent == NULL) return; DBG("Installing GPIO functions for macio %s\n", macio->of_node->full_name); /* * Ok, got one, we dont need anything special to track them down, so * we just create them all */ for (gp = NULL; (gp = of_get_next_child(gparent, gp)) != NULL;) { const u32 *reg = of_get_property(gp, "reg", NULL); unsigned long offset; if (reg == NULL) continue; offset = *reg; /* Deal with old style device-tree. We can safely hard code the * offset for now too even if it's a bit gross ... */ if (offset < 0x50) offset += 0x50; offset += (unsigned long)macio->base; pmf_register_driver(gp, &macio_gpio_handlers, (void *)offset); } DBG("Calling initial GPIO functions for macio %s\n", macio->of_node->full_name); /* And now we run all the init ones */ for (gp = NULL; (gp = of_get_next_child(gparent, gp)) != NULL;) pmf_do_functions(gp, NULL, 0, PMF_FLAGS_ON_INIT, NULL); /* Note: We do not at this point implement the "at sleep" or "at wake" * functions. I yet to find any for GPIOs anyway */ } static int macio_do_write_reg32(PMF_STD_ARGS, u32 offset, u32 value, u32 mask) { struct macio_chip *macio = func->driver_data; unsigned long flags; raw_spin_lock_irqsave(&feature_lock, flags); MACIO_OUT32(offset, (MACIO_IN32(offset) & ~mask) | (value & mask)); raw_spin_unlock_irqrestore(&feature_lock, flags); return 0; } static int macio_do_read_reg32(PMF_STD_ARGS, u32 offset) { struct macio_chip *macio = func->driver_data; /* Check if we have room for reply */ if (args == NULL || args->count == 0 || args->u[0].p == NULL) return -EINVAL; *args->u[0].p = MACIO_IN32(offset); return 0; } static int macio_do_write_reg8(PMF_STD_ARGS, u32 offset, u8 value, u8 mask) { struct macio_chip *macio = func->driver_data; unsigned long flags; raw_spin_lock_irqsave(&feature_lock, flags); MACIO_OUT8(offset, (MACIO_IN8(offset) & ~mask) | (value & mask)); raw_spin_unlock_irqrestore(&feature_lock, flags); return 0; } static int macio_do_read_reg8(PMF_STD_ARGS, u32 offset) { struct macio_chip *macio = func->driver_data; /* Check if we have room for reply */ if (args == NULL || args->count == 0 || args->u[0].p == NULL) return -EINVAL; *((u8 *)(args->u[0].p)) = MACIO_IN8(offset); return 0; } static int macio_do_read_reg32_msrx(PMF_STD_ARGS, u32 offset, u32 mask, u32 shift, u32 xor) { struct macio_chip *macio = func->driver_data; /* Check if we have room for reply */ if (args == NULL || args->count == 0 || args->u[0].p == NULL) return -EINVAL; *args->u[0].p = ((MACIO_IN32(offset) & mask) >> shift) ^ xor; return 0; } static int macio_do_read_reg8_msrx(PMF_STD_ARGS, u32 offset, u32 mask, u32 shift, u32 xor) { struct macio_chip *macio = func->driver_data; /* Check if we have room for reply */ if (args == NULL || args->count == 0 || args->u[0].p == NULL) return -EINVAL; *((u8 *)(args->u[0].p)) = ((MACIO_IN8(offset) & mask) >> shift) ^ xor; return 0; } static int macio_do_write_reg32_slm(PMF_STD_ARGS, u32 offset, u32 shift, u32 mask) { struct macio_chip *macio = func->driver_data; unsigned long flags; u32 tmp, val; /* Check args */ if (args == NULL || args->count == 0) return -EINVAL; raw_spin_lock_irqsave(&feature_lock, flags); tmp = MACIO_IN32(offset); val = args->u[0].v << shift; tmp = (tmp & ~mask) | (val & mask); MACIO_OUT32(offset, tmp); raw_spin_unlock_irqrestore(&feature_lock, flags); return 0; } static int macio_do_write_reg8_slm(PMF_STD_ARGS, u32 offset, u32 shift, u32 mask) { struct macio_chip *macio = func->driver_data; unsigned long flags; u32 tmp, val; /* Check args */ if (args == NULL || args->count == 0) return -EINVAL; raw_spin_lock_irqsave(&feature_lock, flags); tmp = MACIO_IN8(offset); val = args->u[0].v << shift; tmp = (tmp & ~mask) | (val & mask); MACIO_OUT8(offset, tmp); raw_spin_unlock_irqrestore(&feature_lock, flags); return 0; } static struct pmf_handlers macio_mmio_handlers = { .write_reg32 = macio_do_write_reg32, .read_reg32 = macio_do_read_reg32, .write_reg8 = macio_do_write_reg8, .read_reg8 = macio_do_read_reg8, .read_reg32_msrx = macio_do_read_reg32_msrx, .read_reg8_msrx = macio_do_read_reg8_msrx, .write_reg32_slm = macio_do_write_reg32_slm, .write_reg8_slm = macio_do_write_reg8_slm, .delay = macio_do_delay, }; static void macio_mmio_init_one(struct macio_chip *macio) { DBG("Installing MMIO functions for macio %s\n", macio->of_node->full_name); pmf_register_driver(macio->of_node, &macio_mmio_handlers, macio); } static struct device_node *unin_hwclock; static int unin_do_write_reg32(PMF_STD_ARGS, u32 offset, u32 value, u32 mask) { unsigned long flags; raw_spin_lock_irqsave(&feature_lock, flags); /* This is fairly bogus in darwin, but it should work for our needs * implemeted that way: */ UN_OUT(offset, (UN_IN(offset) & ~mask) | (value & mask)); raw_spin_unlock_irqrestore(&feature_lock, flags); return 0; } static struct pmf_handlers unin_mmio_handlers = { .write_reg32 = unin_do_write_reg32, .delay = macio_do_delay, }; static void uninorth_install_pfunc(void) { struct device_node *np; DBG("Installing functions for UniN %s\n", uninorth_node->full_name); /* * Install handlers for the bridge itself */ pmf_register_driver(uninorth_node, &unin_mmio_handlers, NULL); pmf_do_functions(uninorth_node, NULL, 0, PMF_FLAGS_ON_INIT, NULL); /* * Install handlers for the hwclock child if any */ for (np = NULL; (np = of_get_next_child(uninorth_node, np)) != NULL;) if (strcmp(np->name, "hw-clock") == 0) { unin_hwclock = np; break; } if (unin_hwclock) { DBG("Installing functions for UniN clock %s\n", unin_hwclock->full_name); pmf_register_driver(unin_hwclock, &unin_mmio_handlers, NULL); pmf_do_functions(unin_hwclock, NULL, 0, PMF_FLAGS_ON_INIT, NULL); } } /* We export this as the SMP code might init us early */ int __init pmac_pfunc_base_install(void) { static int pfbase_inited; int i; if (pfbase_inited) return 0; pfbase_inited = 1; if (!machine_is(powermac)) return 0; DBG("Installing base platform functions...\n"); /* * Locate mac-io chips and install handlers */ for (i = 0 ; i < MAX_MACIO_CHIPS; i++) { if (macio_chips[i].of_node) { macio_mmio_init_one(&macio_chips[i]); macio_gpio_init_one(&macio_chips[i]); } } /* * Install handlers for northbridge and direct mapped hwclock * if any. We do not implement the config space access callback * which is only ever used for functions that we do not call in * the current driver (enabling/disabling cells in U2, mostly used * to restore the PCI settings, we do that differently) */ if (uninorth_node && uninorth_base) uninorth_install_pfunc(); DBG("All base functions installed\n"); return 0; } machine_arch_initcall(powermac, pmac_pfunc_base_install); #ifdef CONFIG_PM /* Those can be called by pmac_feature. Ultimately, I should use a sysdev * or a device, but for now, that's good enough until I sort out some * ordering issues. Also, we do not bother with GPIOs, as so far I yet have * to see a case where a GPIO function has the on-suspend or on-resume bit */ void pmac_pfunc_base_suspend(void) { int i; for (i = 0 ; i < MAX_MACIO_CHIPS; i++) { if (macio_chips[i].of_node) pmf_do_functions(macio_chips[i].of_node, NULL, 0, PMF_FLAGS_ON_SLEEP, NULL); } if (uninorth_node) pmf_do_functions(uninorth_node, NULL, 0, PMF_FLAGS_ON_SLEEP, NULL); if (unin_hwclock) pmf_do_functions(unin_hwclock, NULL, 0, PMF_FLAGS_ON_SLEEP, NULL); } void pmac_pfunc_base_resume(void) { int i; if (unin_hwclock) pmf_do_functions(unin_hwclock, NULL, 0, PMF_FLAGS_ON_WAKE, NULL); if (uninorth_node) pmf_do_functions(uninorth_node, NULL, 0, PMF_FLAGS_ON_WAKE, NULL); for (i = 0 ; i < MAX_MACIO_CHIPS; i++) { if (macio_chips[i].of_node) pmf_do_functions(macio_chips[i].of_node, NULL, 0, PMF_FLAGS_ON_WAKE, NULL); } } #endif /* CONFIG_PM */