[75] | 1 | /* |
---|
| 2 | * soclib_tty.c - soclib tty driver implementation. |
---|
| 3 | * |
---|
| 4 | * Author Alain Greiner (2016) |
---|
| 5 | * |
---|
| 6 | * Copyright (c) UPMC Sorbonne Universites |
---|
| 7 | * |
---|
| 8 | * This file is part of ALMOS-MKH.. |
---|
| 9 | * |
---|
| 10 | * ALMOS-MKH. is free software; you can redistribute it and/or modify it |
---|
| 11 | * under the terms of the GNU General Public License as published by |
---|
| 12 | * the Free Software Foundation; version 2.0 of the License. |
---|
| 13 | * |
---|
| 14 | * ALMOS-MKH. is distributed in the hope that it will be useful, but |
---|
| 15 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
---|
| 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
---|
| 17 | * General Public License for more details. |
---|
| 18 | * |
---|
| 19 | * You should have received a copy of the GNU General Public License |
---|
| 20 | * along with ALMOS-MKH.; if not, write to the Free Software Foundation, |
---|
| 21 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
---|
| 22 | */ |
---|
| 23 | |
---|
| 24 | #include <dev_txt.h> |
---|
| 25 | #include <chdev.h> |
---|
| 26 | #include <soclib_tty.h> |
---|
| 27 | #include <remote_spinlock.h> |
---|
| 28 | #include <thread.h> |
---|
[407] | 29 | #include <printk.h> |
---|
[75] | 30 | #include <hal_special.h> |
---|
| 31 | |
---|
[407] | 32 | #if CONFIG_READ_DEBUG |
---|
| 33 | extern uint32_t enter_tty_cmd; |
---|
| 34 | extern uint32_t exit_tty_cmd; |
---|
| 35 | |
---|
| 36 | extern uint32_t enter_tty_isr; |
---|
| 37 | extern uint32_t exit_tty_isr; |
---|
| 38 | #endif |
---|
| 39 | |
---|
[75] | 40 | /////////////////////////////////////// |
---|
| 41 | void soclib_tty_init( chdev_t * chdev ) |
---|
| 42 | { |
---|
[407] | 43 | xptr_t reg_xp; |
---|
| 44 | |
---|
[77] | 45 | chdev->cmd = &soclib_tty_cmd; |
---|
| 46 | chdev->isr = &soclib_tty_isr; |
---|
[407] | 47 | chdev->aux = &soclib_tty_aux; |
---|
[77] | 48 | |
---|
[407] | 49 | // get TTY channel and extended pointer on TTY peripheral base address |
---|
| 50 | xptr_t tty_xp = chdev->base; |
---|
| 51 | uint32_t channel = chdev->channel; |
---|
[75] | 52 | |
---|
| 53 | // get SOCLIB_TTY device cluster and local pointer |
---|
| 54 | cxy_t tty_cxy = GET_CXY( tty_xp ); |
---|
| 55 | uint32_t * tty_ptr = (uint32_t *)GET_PTR( tty_xp ); |
---|
| 56 | |
---|
[407] | 57 | // reset TTY_RX_IRQ_ENABLE |
---|
| 58 | reg_xp = XPTR( tty_cxy , tty_ptr + (channel * TTY_SPAN) + TTY_RX_IRQ_ENABLE ); |
---|
| 59 | hal_remote_sw( reg_xp , 0 ); |
---|
| 60 | |
---|
| 61 | // reset TTY_TX_IRQ_ENABLE |
---|
| 62 | reg_xp = XPTR( tty_cxy , tty_ptr + (channel * TTY_SPAN) + TTY_TX_IRQ_ENABLE ); |
---|
| 63 | hal_remote_sw( reg_xp , 0 ); |
---|
[75] | 64 | } |
---|
| 65 | |
---|
| 66 | ////////////////////////////////////////////////////////////// |
---|
| 67 | void __attribute__ ((noinline)) soclib_tty_cmd( xptr_t th_xp ) |
---|
| 68 | { |
---|
[407] | 69 | |
---|
| 70 | #if CONFIG_READ_DEBUG |
---|
| 71 | enter_tty_cmd = hal_time_stamp(); |
---|
| 72 | #endif |
---|
| 73 | |
---|
| 74 | txt_dmsg("\n[DBG] %s : core[%x,%d] / DEV thread enter / cycle %d\n", |
---|
| 75 | __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , hal_time_stamp() ); |
---|
| 76 | |
---|
[75] | 77 | // get client thread cluster and local pointer |
---|
| 78 | cxy_t th_cxy = GET_CXY( th_xp ); |
---|
| 79 | thread_t * th_ptr = (thread_t *)GET_PTR( th_xp ); |
---|
| 80 | |
---|
| 81 | // get command type and extended pointer on TXT device |
---|
[279] | 82 | uint32_t type = hal_remote_lw ( XPTR( th_cxy , &th_ptr->txt_cmd.type ) ); |
---|
| 83 | xptr_t dev_xp = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->txt_cmd.dev_xp ) ); |
---|
[75] | 84 | |
---|
[407] | 85 | assert( (type == TXT_READ) || (type == TXT_WRITE) , __FUNCTION__, "illegal command type"); |
---|
| 86 | |
---|
[75] | 87 | // get TXT device cluster and local pointer |
---|
| 88 | cxy_t dev_cxy = GET_CXY( dev_xp ); |
---|
| 89 | chdev_t * dev_ptr = (chdev_t *)GET_PTR( dev_xp ); |
---|
| 90 | |
---|
| 91 | // get extended pointer on SOCLIB_TTY base segment |
---|
| 92 | xptr_t tty_xp = (xptr_t)hal_remote_lwd( XPTR( dev_cxy , &dev_ptr->base ) ); |
---|
| 93 | |
---|
| 94 | // get SOCLIB_TTY base segment cluster and local pointer |
---|
| 95 | cxy_t tty_cxy = GET_CXY( tty_xp ); |
---|
| 96 | uint32_t * tty_ptr = (uint32_t *)GET_PTR( tty_xp ); |
---|
| 97 | |
---|
| 98 | // get TTY channel index and channel base address |
---|
| 99 | uint32_t channel = hal_remote_lw( XPTR( dev_cxy , &dev_ptr->channel ) ); |
---|
| 100 | uint32_t * base = tty_ptr + TTY_SPAN * channel; |
---|
| 101 | |
---|
[407] | 102 | // compute extended pointer on relevant TTY register |
---|
| 103 | xptr_t reg_xp; |
---|
| 104 | if( type == TXT_READ ) reg_xp = XPTR( tty_cxy , base + TTY_RX_IRQ_ENABLE ); |
---|
| 105 | else reg_xp = XPTR( tty_cxy , base + TTY_TX_IRQ_ENABLE ); |
---|
[75] | 106 | |
---|
[407] | 107 | // enable relevant IRQ : data transfer will be done by the TTY_RX ISR) |
---|
| 108 | hal_remote_sw( reg_xp , 1 ); |
---|
[75] | 109 | |
---|
[407] | 110 | txt_dmsg("\n[DBG] %s : core[%x,%d] DEV thread deschedule / cycle %d\n", |
---|
| 111 | __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , hal_time_stamp() ); |
---|
[75] | 112 | |
---|
[407] | 113 | // Block and deschedule server thread |
---|
| 114 | thread_block( CURRENT_THREAD , THREAD_BLOCKED_DEV_ISR ); |
---|
[408] | 115 | sched_yield("blocked on ISR"); |
---|
[75] | 116 | |
---|
[407] | 117 | txt_dmsg("\n[DBG] %s : core[%x,%d] / DEV thread resume / cycle %d\n", |
---|
| 118 | __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , hal_time_stamp() ); |
---|
| 119 | |
---|
| 120 | #if CONFIG_READ_DEBUG |
---|
| 121 | exit_tty_cmd = hal_time_stamp(); |
---|
| 122 | #endif |
---|
| 123 | |
---|
| 124 | } // end soclib_tty_cmd() |
---|
| 125 | |
---|
| 126 | ///////////////////////////////////////////////////////////// |
---|
| 127 | void __attribute__ ((noinline)) soclib_tty_aux( void * args ) |
---|
| 128 | { |
---|
| 129 | uint32_t status; |
---|
| 130 | bool_t empty; |
---|
| 131 | uint32_t i; |
---|
| 132 | |
---|
| 133 | xptr_t dev_xp = ((txt_aux_t *)args)->dev_xp; |
---|
| 134 | char * buffer = ((txt_aux_t *)args)->buffer; |
---|
| 135 | uint32_t count = ((txt_aux_t *)args)->count; |
---|
| 136 | |
---|
| 137 | // get TXT0 chdev cluster and local pointer |
---|
| 138 | cxy_t dev_cxy = GET_CXY( dev_xp ); |
---|
| 139 | chdev_t * dev_ptr = (chdev_t *)GET_PTR( dev_xp ); |
---|
| 140 | |
---|
| 141 | // get extended pointer on TTY channel base address |
---|
| 142 | xptr_t tty_xp = (xptr_t)hal_remote_lwd( XPTR( dev_cxy , &dev_ptr->base ) ); |
---|
| 143 | |
---|
| 144 | // get TTY channel segment cluster and local pointer |
---|
| 145 | cxy_t tty_cxy = GET_CXY( tty_xp ); |
---|
| 146 | uint32_t * tty_ptr = (uint32_t *)GET_PTR( tty_xp ); |
---|
| 147 | |
---|
| 148 | // get extended pointers on TTY_WRITE & TTY_STATUS registers |
---|
| 149 | xptr_t write_xp = XPTR( tty_cxy , tty_ptr + TTY_WRITE ); |
---|
| 150 | xptr_t status_xp = XPTR( tty_cxy , tty_ptr + TTY_STATUS ); |
---|
| 151 | |
---|
| 152 | // loop on characters (busy waiting strategy) |
---|
| 153 | for( i = 0 ; i < count ; i++ ) |
---|
| 154 | { |
---|
| 155 | do |
---|
[75] | 156 | { |
---|
[407] | 157 | // get TTY_STATUS |
---|
| 158 | status = hal_remote_lw( status_xp ); |
---|
| 159 | empty = ( (status & TTY_STATUS_TX_FULL) == 0 ); |
---|
[75] | 160 | |
---|
[407] | 161 | // transfer one byte if TX buffer empty |
---|
| 162 | if ( empty ) hal_remote_sb( write_xp , buffer[i] ); |
---|
[75] | 163 | } |
---|
[407] | 164 | while ( empty == false ); |
---|
[75] | 165 | } |
---|
[407] | 166 | } // end soclib_tty_aux() |
---|
[75] | 167 | |
---|
[279] | 168 | |
---|
[75] | 169 | ///////////////////////////////////////////////////////////////// |
---|
| 170 | void __attribute__ ((noinline)) soclib_tty_isr( chdev_t * chdev ) |
---|
| 171 | { |
---|
| 172 | uint32_t type; // command type |
---|
| 173 | uint32_t count; // number of bytes in buffer |
---|
[407] | 174 | xptr_t buf_xp; // extended pointer on buffer |
---|
| 175 | xptr_t status_xp; // extended pointer on TTY_STATUS register |
---|
| 176 | xptr_t write_xp; // extended pointer on TTY_WRITE register |
---|
| 177 | xptr_t read_xp; // extended pointer on TTY_READ register |
---|
[75] | 178 | uint32_t status; // TTY terminal status |
---|
| 179 | char byte; // read byte |
---|
| 180 | uint32_t i; |
---|
| 181 | |
---|
[424] | 182 | #if (CONFIG_READ_DEBUG & 0x1) || (CONFIG_WRITE_DEBUG & 0x1) |
---|
[407] | 183 | enter_tty_isr = hal_time_stamp(); |
---|
| 184 | #endif |
---|
| 185 | |
---|
[75] | 186 | // get extended pointer on client thread |
---|
| 187 | xptr_t root = XPTR( local_cxy , &chdev->wait_root ); |
---|
| 188 | xptr_t client_xp = XLIST_FIRST_ELEMENT( root , thread_t , wait_list ); |
---|
| 189 | |
---|
| 190 | // get client thread cluster and local pointer |
---|
| 191 | cxy_t client_cxy = GET_CXY( client_xp ); |
---|
| 192 | thread_t * client_ptr = (thread_t *)GET_PTR( client_xp ); |
---|
| 193 | |
---|
| 194 | // get command arguments |
---|
[279] | 195 | type = hal_remote_lw ( XPTR( client_cxy , &client_ptr->txt_cmd.type ) ); |
---|
| 196 | count = hal_remote_lw ( XPTR( client_cxy , &client_ptr->txt_cmd.count ) ); |
---|
| 197 | buf_xp = hal_remote_lwd( XPTR( client_cxy , &client_ptr->txt_cmd.buf_xp ) ); |
---|
[75] | 198 | |
---|
[407] | 199 | txt_dmsg("\n[DBG] %s : core[%x,%d] enter / cycle %d\n", |
---|
| 200 | __FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid , hal_time_stamp() ); |
---|
| 201 | |
---|
[75] | 202 | // get SOCLIB_TTY peripheral cluster and local pointer |
---|
| 203 | cxy_t tty_cxy = GET_CXY( chdev->base ); |
---|
| 204 | uint32_t * tty_ptr = (uint32_t *)GET_PTR( chdev->base ); |
---|
| 205 | |
---|
| 206 | // get channel base address |
---|
| 207 | uint32_t * base = tty_ptr + TTY_SPAN * chdev->channel; |
---|
| 208 | |
---|
[407] | 209 | // get extended pointer on TTY registers |
---|
| 210 | status_xp = XPTR( tty_cxy , base + TTY_STATUS ); |
---|
| 211 | write_xp = XPTR( tty_cxy , base + TTY_WRITE ); |
---|
| 212 | read_xp = XPTR( tty_cxy , base + TTY_READ ); |
---|
| 213 | |
---|
[75] | 214 | if( type == TXT_READ ) // read one single character |
---|
| 215 | { |
---|
[407] | 216 | // get TTY_STATUS |
---|
| 217 | status = hal_remote_lw( status_xp ); |
---|
[75] | 218 | |
---|
[407] | 219 | if( status & TTY_STATUS_RX_FULL ) // TTY_RX full => move one byte |
---|
[75] | 220 | { |
---|
[407] | 221 | // get a byte from TTY_READ, and acknowledge RX_IRQ |
---|
| 222 | byte = (char)hal_remote_lb( read_xp ); |
---|
[75] | 223 | |
---|
| 224 | // write it to command buffer |
---|
| 225 | hal_remote_sb( buf_xp , byte ); |
---|
| 226 | } |
---|
| 227 | else // buffer empty => exit ISR for retry |
---|
| 228 | { |
---|
| 229 | return; |
---|
| 230 | } |
---|
[407] | 231 | |
---|
| 232 | // disable RX_IRQ |
---|
| 233 | xptr_t reg_xp = XPTR( tty_cxy , base + TTY_RX_IRQ_ENABLE ); |
---|
| 234 | hal_remote_sw( reg_xp , 0 ); |
---|
[75] | 235 | } |
---|
[407] | 236 | else if( type == TXT_WRITE ) // write all characters in string |
---|
[75] | 237 | { |
---|
| 238 | // loop on characters |
---|
| 239 | for( i = 0 ; i < count ; i++ ) |
---|
| 240 | { |
---|
[407] | 241 | // get TTY_STATUS |
---|
| 242 | status = hal_remote_lw( status_xp ); |
---|
[75] | 243 | |
---|
[407] | 244 | if( (status & TTY_STATUS_TX_FULL) == 0 ) // TTY_TX empty => move one byte |
---|
[75] | 245 | { |
---|
| 246 | // get one byte from command buffer |
---|
| 247 | byte = (char)hal_remote_lb( buf_xp + i ); |
---|
| 248 | |
---|
[407] | 249 | // write byte to TTY_WRITE, and acknowledge TX_IRQ |
---|
| 250 | hal_remote_sb( write_xp , byte ); |
---|
[75] | 251 | } |
---|
| 252 | else // TTY_TX full => update command arguments and exit ISR for retry |
---|
| 253 | { |
---|
[279] | 254 | hal_remote_sw ( XPTR( client_cxy , &client_ptr->txt_cmd.count ), count-i ); |
---|
| 255 | hal_remote_swd( XPTR( client_cxy , &client_ptr->txt_cmd.buf_xp ), buf_xp+i ); |
---|
[75] | 256 | return; |
---|
| 257 | } |
---|
| 258 | } |
---|
[407] | 259 | |
---|
| 260 | // disable TX_IRQ |
---|
| 261 | xptr_t reg_xp = XPTR( tty_cxy , base + TTY_TX_IRQ_ENABLE ); |
---|
| 262 | hal_remote_sw( reg_xp , 0 ); |
---|
[75] | 263 | } |
---|
| 264 | |
---|
| 265 | // The I/O operation completed when we reach this point |
---|
| 266 | |
---|
| 267 | // set I/O operation status in command |
---|
[279] | 268 | hal_remote_sw( XPTR( client_cxy , &client_ptr->txt_cmd.error ) , 0 ); |
---|
[75] | 269 | |
---|
| 270 | // unblock server thread |
---|
[407] | 271 | thread_unblock( XPTR( local_cxy , chdev->server ) , THREAD_BLOCKED_DEV_ISR ); |
---|
[75] | 272 | |
---|
| 273 | // unblock client thread |
---|
[418] | 274 | // thread_unblock( client_xp , THREAD_BLOCKED_IO ); |
---|
[75] | 275 | |
---|
[407] | 276 | hal_fence(); |
---|
| 277 | |
---|
| 278 | txt_dmsg("\n[DBG] %s : core[%x,%d] exit / cycle %d\n", |
---|
| 279 | __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , hal_time_stamp() ); |
---|
| 280 | |
---|
[424] | 281 | #if (CONFIG_READ_DEBUG & 0x1) || (CONFIG_WRITE_DEBUG & 0x1) |
---|
[407] | 282 | exit_tty_isr = hal_time_stamp(); |
---|
| 283 | #endif |
---|
| 284 | |
---|
[279] | 285 | } // end soclib_tty_isr() |
---|
| 286 | |
---|
[424] | 287 | /* |
---|
| 288 | ///////////////////////////////////////////////////////////////// |
---|
| 289 | void __attribute__ ((noinline)) soclib_tty_isr( chdev_t * chdev ) |
---|
| 290 | { |
---|
| 291 | xptr_t root_xp; // extended pointer on command list root |
---|
| 292 | xptr_t client_xp; // extended pointer on client thread |
---|
| 293 | cxy_t client_cxy; // client thread cluster |
---|
| 294 | thread_t * client_ptr; // client_thread local pointer |
---|
| 295 | uint32_t type; // command type |
---|
| 296 | uint32_t count; // number of bytes in buffer |
---|
| 297 | xptr_t buf_xp; // extended pointer on buffer |
---|
| 298 | xptr_t status_xp; // extended pointer on TTY_STATUS register |
---|
| 299 | xptr_t write_xp; // extended pointer on TTY_WRITE register |
---|
| 300 | xptr_t read_xp; // extended pointer on TTY_READ register |
---|
| 301 | uint32_t status; // TTY terminal status |
---|
| 302 | char byte; // read byte |
---|
| 303 | uint32_t i; |
---|
| 304 | |
---|
| 305 | #if (CONFIG_READ_DEBUG & 0x1) || (CONFIG_WRITE_DEBUG & 0x1) |
---|
| 306 | enter_tty_isr = hal_time_stamp(); |
---|
| 307 | #endif |
---|
| 308 | |
---|
| 309 | txt_dmsg("\n[DBG] %s : core[%x,%d] enter / cycle %d\n", |
---|
| 310 | __FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid , hal_time_stamp() ); |
---|
| 311 | |
---|
| 312 | // get SOCLIB_TTY peripheral cluster and local pointer |
---|
| 313 | cxy_t tty_cxy = GET_CXY( chdev->base ); |
---|
| 314 | uint32_t * tty_ptr = (uint32_t *)GET_PTR( chdev->base ); |
---|
| 315 | |
---|
| 316 | // get channel base address |
---|
| 317 | uint32_t * base = tty_ptr + TTY_SPAN * chdev->channel; |
---|
| 318 | |
---|
| 319 | // get extended pointer on TTY registers |
---|
| 320 | status_xp = XPTR( tty_cxy , base + TTY_STATUS ); |
---|
| 321 | write_xp = XPTR( tty_cxy , base + TTY_WRITE ); |
---|
| 322 | read_xp = XPTR( tty_cxy , base + TTY_READ ); |
---|
| 323 | |
---|
| 324 | // get TTY_STATUS |
---|
| 325 | status = hal_remote_lw( status_xp ); |
---|
| 326 | |
---|
| 327 | // get extended pointer on the command list root |
---|
| 328 | root_xp = XPTR( local_cxy , &chdev->wait_root ); |
---|
| 329 | |
---|
| 330 | // get extended pointer on client thread |
---|
| 331 | if(xlist_is_empty(root_xp)) client_xp = XLIST_FIRST_ELEMENT(root, thread_t, wait_list); |
---|
| 332 | else client_xp = XPTR_NULL; |
---|
| 333 | |
---|
| 334 | if( client_xp ) |
---|
| 335 | { |
---|
| 336 | // get client thread cluster and local pointer |
---|
| 337 | client_cxy = GET_CXY( client_xp ); |
---|
| 338 | client_ptr = (thread_t *)GET_PTR( client_xp ); |
---|
| 339 | |
---|
| 340 | // get command arguments |
---|
| 341 | type = hal_remote_lw ( XPTR( client_cxy , &client_ptr->txt_cmd.type ) ); |
---|
| 342 | count = hal_remote_lw ( XPTR( client_cxy , &client_ptr->txt_cmd.count ) ); |
---|
| 343 | buf_xp = hal_remote_lwd( XPTR( client_cxy , &client_ptr->txt_cmd.buf_xp ) ); |
---|
| 344 | } |
---|
| 345 | |
---|
| 346 | ///////////// handle RX if TTY_RX full |
---|
| 347 | if( status & TTY_STATUS_RX_FULL ) |
---|
| 348 | { |
---|
| 349 | // get a byte from TTY_READ, and acknowledge RX_IRQ |
---|
| 350 | byte = (char)hal_remote_lb( read_xp ); |
---|
| 351 | |
---|
| 352 | // FIXME The RX_IRQ must be always enabled !!! |
---|
| 353 | // xptr_t reg_xp = XPTR( tty_cxy , base + TTY_RX_IRQ_ENABLE ); |
---|
| 354 | // hal_remote_sw( reg_xp , 0 ); |
---|
| 355 | |
---|
| 356 | // analyse received character |
---|
| 357 | switch( byte ) |
---|
| 358 | { |
---|
| 359 | case CONTROL_C: // SIGINT to process |
---|
| 360 | case CONTROL_D: |
---|
| 361 | { |
---|
| 362 | // TODO SIGINT |
---|
| 363 | return |
---|
| 364 | } |
---|
| 365 | break; |
---|
| 366 | default: |
---|
| 367 | { |
---|
| 368 | if( (type == TXT_READ) && (client_xp != XPTR_NULL) ) |
---|
| 369 | { |
---|
| 370 | // write byte to command buffer |
---|
| 371 | hal_remote_sb( buf_xp , byte ); |
---|
| 372 | |
---|
| 373 | // set status in command |
---|
| 374 | hal_remote_sw( XPTR( client_cxy , &client_ptr->txt_cmd.error ) , 0 ); |
---|
| 375 | |
---|
| 376 | hal_fence(); |
---|
| 377 | |
---|
| 378 | // unblock server thread |
---|
| 379 | thread_unblock( XPTR(local_cxy,chdev->server), THREAD_BLOCKED_DEV_ISR ); |
---|
| 380 | } |
---|
| 381 | else // discard byte |
---|
| 382 | { |
---|
| 383 | // TODO WARNING |
---|
| 384 | return |
---|
| 385 | } |
---|
| 386 | } |
---|
| 387 | } |
---|
| 388 | } // end RX handling |
---|
| 389 | |
---|
| 390 | //////////////// handle TX if WRITE command pending |
---|
| 391 | if( (type == TXT_WRITE) && (client_xp != XPTR_NULL) ) |
---|
| 392 | { |
---|
| 393 | // loop on characters |
---|
| 394 | for( i = 0 ; i < count ; i++ ) |
---|
| 395 | { |
---|
| 396 | // get TTY_STATUS |
---|
| 397 | status = hal_remote_lw( status_xp ); |
---|
| 398 | |
---|
| 399 | if( (status & TTY_STATUS_TX_FULL) == 0 ) // TTY_TX empty => move one byte |
---|
| 400 | { |
---|
| 401 | // get one byte from command buffer |
---|
| 402 | byte = (char)hal_remote_lb( buf_xp + i ); |
---|
| 403 | |
---|
| 404 | // write byte to TTY_WRITE, and acknowledge TX_IRQ |
---|
| 405 | hal_remote_sb( write_xp , byte ); |
---|
| 406 | } |
---|
| 407 | else // TTY_TX full => update command arguments and exit ISR for retry |
---|
| 408 | { |
---|
| 409 | hal_remote_sw ( XPTR( client_cxy , &client_ptr->txt_cmd.count ), count-i ); |
---|
| 410 | hal_remote_swd( XPTR( client_cxy , &client_ptr->txt_cmd.buf_xp ), buf_xp+i ); |
---|
| 411 | return; |
---|
| 412 | } |
---|
| 413 | } |
---|
| 414 | |
---|
| 415 | // disable TX_IRQ |
---|
| 416 | xptr_t reg_xp = XPTR( tty_cxy , base + TTY_TX_IRQ_ENABLE ); |
---|
| 417 | hal_remote_sw( reg_xp , 0 ); |
---|
| 418 | |
---|
| 419 | // set I/O operation status in command |
---|
| 420 | hal_remote_sw( XPTR( client_cxy , &client_ptr->txt_cmd.error ) , 0 ); |
---|
| 421 | |
---|
| 422 | hal_fence(); |
---|
| 423 | |
---|
| 424 | // unblock server thread |
---|
| 425 | thread_unblock( XPTR( local_cxy , chdev->server ) , THREAD_BLOCKED_DEV_ISR ); |
---|
| 426 | |
---|
| 427 | } // end TX handling |
---|
| 428 | |
---|
| 429 | txt_dmsg("\n[DBG] %s : core[%x,%d] exit / cycle %d\n", |
---|
| 430 | __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , hal_time_stamp() ); |
---|
| 431 | |
---|
| 432 | #if (CONFIG_READ_DEBUG & 0x1) || (CONFIG_WRITE_DEBUG & 0x1) |
---|
| 433 | exit_tty_isr = hal_time_stamp(); |
---|
| 434 | #endif |
---|
| 435 | |
---|
| 436 | } // end soclib_tty_isr() |
---|
| 437 | |
---|
| 438 | */ |
---|