1 /*- 2 * Copyright 2016-2021 Microchip Technology, Inc. and/or its subsidiaries. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 23 * SUCH DAMAGE. 24 */ 25 26 27 #include "smartpqi_includes.h" 28 29 /* 30 * Populate hostwellness time variables in bcd format from FreeBSD format 31 */ 32 void 33 os_get_time(struct bmic_host_wellness_time *host_wellness_time) 34 { 35 struct timespec ts; 36 struct clocktime ct; 37 38 getnanotime(&ts); 39 clock_ts_to_ct(&ts, &ct); 40 41 /* Fill the time In BCD Format */ 42 host_wellness_time->hour= (uint8_t)bin2bcd(ct.hour); 43 host_wellness_time->min = (uint8_t)bin2bcd(ct.min); 44 host_wellness_time->sec= (uint8_t)bin2bcd(ct.sec); 45 host_wellness_time->reserved = 0; 46 host_wellness_time->month = (uint8_t)bin2bcd(ct.mon); 47 host_wellness_time->day = (uint8_t)bin2bcd(ct.day); 48 host_wellness_time->century = (uint8_t)bin2bcd(ct.year / 100); 49 host_wellness_time->year = (uint8_t)bin2bcd(ct.year % 100); 50 51 } 52 53 /* 54 * Update host time to f/w every 24 hours in a periodic timer. 55 */ 56 57 void 58 os_wellness_periodic(void *data) 59 { 60 struct pqisrc_softstate *softs = (struct pqisrc_softstate *)data; 61 int ret = 0; 62 63 /* update time to FW */ 64 if (!pqisrc_ctrl_offline(softs)){ 65 if( (ret = pqisrc_write_current_time_to_host_wellness(softs)) != 0 ) 66 DBG_ERR("Failed to update time to FW in periodic ret = %d\n", ret); 67 } 68 69 /* reschedule ourselves */ 70 callout_reset(&softs->os_specific.wellness_periodic, 71 PQI_HOST_WELLNESS_TIMEOUT_SEC * hz, os_wellness_periodic, softs); 72 } 73 74 /* 75 * Routine used to stop the heart-beat timer 76 */ 77 void 78 os_stop_heartbeat_timer(pqisrc_softstate_t *softs) 79 { 80 DBG_FUNC("IN\n"); 81 82 /* Kill the heart beat event */ 83 callout_stop(&softs->os_specific.heartbeat_timeout_id); 84 85 DBG_FUNC("OUT\n"); 86 } 87 88 /* 89 * Routine used to start the heart-beat timer 90 */ 91 void 92 os_start_heartbeat_timer(void *data) 93 { 94 struct pqisrc_softstate *softs = (struct pqisrc_softstate *)data; 95 DBG_FUNC("IN\n"); 96 97 pqisrc_heartbeat_timer_handler(softs); 98 if (!pqisrc_ctrl_offline(softs)) { 99 callout_reset(&softs->os_specific.heartbeat_timeout_id, 100 PQI_HEARTBEAT_TIMEOUT_SEC * hz, 101 os_start_heartbeat_timer, softs); 102 } 103 104 DBG_FUNC("OUT\n"); 105 } 106 107 /* 108 * Mutex initialization function 109 */ 110 int 111 os_init_spinlock(struct pqisrc_softstate *softs, struct mtx *lock, 112 char *lockname) 113 { 114 mtx_init(lock, lockname, NULL, MTX_SPIN); 115 return 0; 116 } 117 118 /* 119 * Mutex uninitialization function 120 */ 121 void 122 os_uninit_spinlock(struct mtx *lock) 123 { 124 mtx_destroy(lock); 125 return; 126 } 127 128 /* 129 * Semaphore initialization function 130 */ 131 int 132 os_create_semaphore(const char *name, int value, struct sema *sema) 133 { 134 sema_init(sema, value, name); 135 return PQI_STATUS_SUCCESS; 136 } 137 138 /* 139 * Semaphore uninitialization function 140 */ 141 int 142 os_destroy_semaphore(struct sema *sema) 143 { 144 sema_destroy(sema); 145 return PQI_STATUS_SUCCESS; 146 } 147 148 /* 149 * Semaphore grab function 150 */ 151 void inline 152 os_sema_lock(struct sema *sema) 153 { 154 sema_post(sema); 155 } 156 157 /* 158 * Semaphore release function 159 */ 160 void inline 161 os_sema_unlock(struct sema *sema) 162 { 163 sema_wait(sema); 164 } 165 166 /* 167 * string copy wrapper function 168 */ 169 int 170 os_strlcpy(char *dst, char *src, int size) 171 { 172 return strlcpy(dst, src, size); 173 } 174 175 int 176 bsd_status_to_pqi_status(int bsd_status) 177 { 178 if (bsd_status == BSD_SUCCESS) 179 return PQI_STATUS_SUCCESS; 180 else 181 return PQI_STATUS_FAILURE; 182 } 183