[1] | 1 | /* |
---|
| 2 | * dev_ioc.c - IOC (Block Device Controler) generic device API implementation. |
---|
[212] | 3 | * |
---|
[1] | 4 | * Author Alain Greiner (2016) |
---|
| 5 | * |
---|
| 6 | * Copyright (c) UPMC Sorbonne Universites |
---|
| 7 | * |
---|
| 8 | * This file is part of ALMOS-MK |
---|
| 9 | * |
---|
[212] | 10 | * ALMOS-MKH is free software; you can redistribute it and/or modify it |
---|
[1] | 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 | * |
---|
[212] | 14 | * ALMOS-MKH is distributed in the hope that it will be useful, but |
---|
[1] | 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 |
---|
[212] | 20 | * along with ALMOS-MKH; if not, write to the Free Software Foundation, |
---|
[1] | 21 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
---|
| 22 | */ |
---|
| 23 | |
---|
[14] | 24 | #include <kernel_config.h> |
---|
[1] | 25 | #include <hal_types.h> |
---|
| 26 | #include <hal_gpt.h> |
---|
[213] | 27 | #include <hal_drivers.h> |
---|
[1] | 28 | #include <soclib_hba.h> |
---|
| 29 | #include <thread.h> |
---|
| 30 | #include <printk.h> |
---|
[3] | 31 | #include <chdev.h> |
---|
[1] | 32 | #include <dev_ioc.h> |
---|
| 33 | |
---|
| 34 | ///////////////////////////////////////////////////////////////////////////////////////// |
---|
| 35 | // Extern global variables |
---|
| 36 | ///////////////////////////////////////////////////////////////////////////////////////// |
---|
| 37 | |
---|
[188] | 38 | extern chdev_directory_t chdev_dir; // allocated in kernel_init.c |
---|
[1] | 39 | |
---|
[188] | 40 | ////////////////////////////////// |
---|
| 41 | void dev_ioc_init( chdev_t * ioc ) |
---|
[1] | 42 | { |
---|
[188] | 43 | // the PIC chdev must be initialized before the IOC chdev, because |
---|
| 44 | // the IOC chdev initialisation requires the routing of an external IRQ |
---|
| 45 | xptr_t pic_xp = chdev_dir.pic; |
---|
[1] | 46 | |
---|
[188] | 47 | assert( (pic_xp != XPTR_NULL) , __FUNCTION__ , "PIC not initialised before IOC" ); |
---|
| 48 | |
---|
[3] | 49 | // get implementation and channel from chdev descriptor |
---|
[188] | 50 | uint32_t impl = ioc->impl; |
---|
| 51 | uint32_t channel = ioc->channel; |
---|
[1] | 52 | |
---|
[23] | 53 | // set chdev name |
---|
[188] | 54 | snprintf( ioc->name , 16 , "ioc_%d" , channel ); |
---|
[23] | 55 | |
---|
[211] | 56 | // call driver init function |
---|
[1] | 57 | if( impl == IMPL_IOC_BDV ) |
---|
| 58 | { |
---|
[213] | 59 | hal_drivers_ioc_init( ioc ); |
---|
[1] | 60 | } |
---|
| 61 | else if( impl == IMPL_IOC_HBA ) |
---|
| 62 | { |
---|
[188] | 63 | soclib_hba_init( ioc ); |
---|
[1] | 64 | } |
---|
| 65 | else |
---|
| 66 | { |
---|
[3] | 67 | assert( false , __FUNCTION__ , "undefined IOC device implementation" ); |
---|
[1] | 68 | } |
---|
| 69 | |
---|
[188] | 70 | // select a core to execute the IOC server thread |
---|
[3] | 71 | lid_t lid = cluster_select_local_core(); |
---|
| 72 | |
---|
[188] | 73 | // bind the IOC IRQ to the selected core |
---|
| 74 | dev_pic_bind_irq( lid , ioc ); |
---|
[3] | 75 | |
---|
[188] | 76 | // enable IRQ |
---|
| 77 | dev_pic_enable_irq( lid ,ioc ); |
---|
[3] | 78 | |
---|
[1] | 79 | // create server thread |
---|
[3] | 80 | thread_t * new_thread; |
---|
[1] | 81 | error_t error; |
---|
| 82 | |
---|
[3] | 83 | error = thread_kernel_create( &new_thread, |
---|
| 84 | THREAD_DEV, |
---|
| 85 | &chdev_sequencial_server, |
---|
[188] | 86 | ioc, |
---|
[212] | 87 | lid ); |
---|
[188] | 88 | |
---|
[3] | 89 | assert( (error == 0) , __FUNCTION__ , "cannot create server thread" ); |
---|
[1] | 90 | |
---|
[188] | 91 | // set "server" field in ioc descriptor |
---|
| 92 | ioc->server = new_thread; |
---|
[212] | 93 | |
---|
[1] | 94 | // start server thread |
---|
[3] | 95 | thread_unblock( XPTR( local_cxy , new_thread ) , THREAD_BLOCKED_GLOBAL ); |
---|
[212] | 96 | |
---|
[1] | 97 | } // end dev_ioc_init() |
---|
| 98 | |
---|
| 99 | ////////////////////////////////////////////////////////////////////////////////// |
---|
| 100 | // This static function is called by dev_ioc_read() & dev_ioc_write() functions. |
---|
[23] | 101 | // It builds and registers the command in the calling thread descriptor. |
---|
[3] | 102 | // Then, it registers the calling thead in chdev waiting queue. |
---|
[1] | 103 | // Finally it blocks on the THREAD_BLOCKED_DEV condition and deschedule. |
---|
| 104 | ////////////////////////////////////i///////////////////////////////////////////// |
---|
[23] | 105 | static error_t dev_ioc_access( uint32_t cmd_type, |
---|
| 106 | uint8_t * buffer, |
---|
| 107 | uint32_t lba, |
---|
| 108 | uint32_t count ) |
---|
[1] | 109 | { |
---|
[3] | 110 | thread_t * this = CURRENT_THREAD; // pointer on client thread |
---|
[1] | 111 | |
---|
| 112 | ioc_dmsg("\n[INFO] in %s : thread %x in process %x" |
---|
[212] | 113 | " for lba = %x / buffer = %x / at cycle %d\n", |
---|
| 114 | __FUNCTION__ , this->trdid , this->process->pid , |
---|
[101] | 115 | lba , (intptr_t)buffer , hal_get_cycles() ); |
---|
[1] | 116 | |
---|
[212] | 117 | // software L2/L3 cache coherence for memory buffer |
---|
| 118 | if( chdev_dir.iob ) |
---|
[68] | 119 | { |
---|
| 120 | if ( cmd_type == IOC_READ ) dev_mmc_inval( XPTR( local_cxy , buffer ) , count<<9 ); |
---|
| 121 | else dev_mmc_sync ( XPTR( local_cxy , buffer ) , count<<9 ); |
---|
| 122 | } |
---|
[1] | 123 | |
---|
[3] | 124 | // get extended pointer on IOC chdev descriptor |
---|
| 125 | xptr_t dev_xp = chdev_dir.ioc[0]; |
---|
[1] | 126 | |
---|
[3] | 127 | assert( (dev_xp != XPTR_NULL) , __FUNCTION__ , "undefined IOC chdev descriptor" ); |
---|
[1] | 128 | |
---|
[3] | 129 | // register command in calling thread descriptor |
---|
| 130 | this->command.ioc.dev_xp = dev_xp; |
---|
[23] | 131 | this->command.ioc.type = cmd_type; |
---|
[3] | 132 | this->command.ioc.buf_xp = XPTR( local_cxy , buffer ); |
---|
| 133 | this->command.ioc.lba = lba; |
---|
| 134 | this->command.ioc.count = count; |
---|
[1] | 135 | |
---|
[3] | 136 | // register client thread in IOC chdev waiting queue, activate server thread, |
---|
[1] | 137 | // block client thread on THREAD_BLOCKED_IO and deschedule. |
---|
| 138 | // it is re-activated by the ISR signaling IO operation completion. |
---|
[3] | 139 | chdev_register_command( dev_xp , this ); |
---|
[1] | 140 | |
---|
[3] | 141 | ioc_dmsg("\n[INFO] in %s : thread %x in process %x" |
---|
[212] | 142 | " completes / error = %d / at cycle %d\n", |
---|
[3] | 143 | __FUNCTION__ , this->trdid , this->process->pid , |
---|
[101] | 144 | this->command.ioc.error , hal_get_cycles() ); |
---|
[1] | 145 | |
---|
| 146 | // return I/O operation status |
---|
[212] | 147 | return this->command.ioc.error; |
---|
[1] | 148 | |
---|
| 149 | } // end dev_ioc_access() |
---|
| 150 | |
---|
| 151 | //////////////////////////////////////////// |
---|
[23] | 152 | error_t dev_ioc_read( uint8_t * buffer, |
---|
[1] | 153 | uint32_t lba, |
---|
| 154 | uint32_t count ) |
---|
| 155 | { |
---|
[212] | 156 | return dev_ioc_access( IOC_READ , buffer , lba , count ); |
---|
| 157 | } |
---|
[1] | 158 | |
---|
| 159 | //////////////////////////////////////////// |
---|
[23] | 160 | error_t dev_ioc_write( uint8_t * buffer, |
---|
| 161 | uint32_t lba, |
---|
| 162 | uint32_t count ) |
---|
[1] | 163 | { |
---|
[212] | 164 | return dev_ioc_access( IOC_WRITE , buffer , lba , count ); |
---|
[1] | 165 | } |
---|
[23] | 166 | |
---|
| 167 | ///////////////////////////////////////////// |
---|
| 168 | error_t dev_ioc_sync_read( uint8_t * buffer, |
---|
| 169 | uint32_t lba, |
---|
| 170 | uint32_t count ) |
---|
| 171 | { |
---|
[212] | 172 | // get pointer on calling thread |
---|
[23] | 173 | thread_t * this = CURRENT_THREAD; |
---|
| 174 | |
---|
[212] | 175 | // software L2/L3 cache coherence for memory buffer |
---|
[68] | 176 | if( chdev_dir.iob ) dev_mmc_inval( XPTR( local_cxy , buffer ) , count<<9 ); |
---|
[23] | 177 | |
---|
[212] | 178 | // get extended pointer on IOC[0] chdev |
---|
[23] | 179 | xptr_t dev_xp = chdev_dir.ioc[0]; |
---|
| 180 | |
---|
| 181 | assert( (dev_xp != XPTR_NULL) , __FUNCTION__ , "undefined IOC chdev descriptor" ); |
---|
| 182 | |
---|
| 183 | // register command in calling thread descriptor |
---|
| 184 | this->command.ioc.dev_xp = dev_xp; |
---|
| 185 | this->command.ioc.type = IOC_SYNC_READ; |
---|
| 186 | this->command.ioc.buf_xp = XPTR( local_cxy , buffer ); |
---|
| 187 | this->command.ioc.lba = lba; |
---|
| 188 | this->command.ioc.count = count; |
---|
| 189 | |
---|
[212] | 190 | // get driver command function |
---|
[23] | 191 | cxy_t dev_cxy = GET_CXY( dev_xp ); |
---|
| 192 | chdev_t * dev_ptr = (chdev_t *)GET_PTR( dev_xp ); |
---|
| 193 | dev_cmd_t * cmd = (dev_cmd_t *)hal_remote_lpt( XPTR( dev_cxy , &dev_ptr->cmd ) ); |
---|
| 194 | |
---|
[207] | 195 | // mask the IRQ |
---|
| 196 | thread_t * server = (thread_t *)hal_remote_lpt( XPTR( dev_cxy , &dev_ptr->server ) ); |
---|
| 197 | core_t * core = (core_t *)hal_remote_lpt( XPTR( dev_cxy , &server->core ) ); |
---|
| 198 | lid_t lid = (lid_t)hal_remote_lw( XPTR( dev_cxy , &core->lid ) ); |
---|
| 199 | dev_pic_disable_irq( lid , dev_xp ); |
---|
| 200 | |
---|
[212] | 201 | // call directly driver command |
---|
[23] | 202 | cmd( XPTR( local_cxy , this ) ); |
---|
| 203 | |
---|
[207] | 204 | // unmask the IRQ |
---|
| 205 | dev_pic_enable_irq( lid , dev_xp ); |
---|
| 206 | |
---|
[23] | 207 | // return I/O operation status from calling thread descriptor |
---|
| 208 | return this->command.ioc.error; |
---|
| 209 | } |
---|
| 210 | |
---|