Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 7e55bed7 in mainline


Ignore:
Timestamp:
2017-10-02T21:07:11Z (4 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master
Children:
e27e36e
Parents:
943aaf1b
Message:

Rename CUDA types, soft state is the basic one.

Location:
uspace/srv/hw/bus/cuda_adb
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/hw/bus/cuda_adb/cuda_adb.c

    r943aaf1b r7e55bed7  
    5555
    5656static void cuda_connection(ipc_callid_t, ipc_call_t *, void *);
    57 static int cuda_init(cuda_instance_t *);
     57static int cuda_init(cuda_t *);
    5858static void cuda_irq_handler(ipc_callid_t, ipc_call_t *, void *);
    5959
    60 static void cuda_irq_listen(cuda_instance_t *);
    61 static void cuda_irq_receive(cuda_instance_t *);
    62 static void cuda_irq_rcv_end(cuda_instance_t *, void *, size_t *);
    63 static void cuda_irq_send_start(cuda_instance_t *);
    64 static void cuda_irq_send(cuda_instance_t *);
    65 
    66 static void cuda_packet_handle(cuda_instance_t *, uint8_t *, size_t);
    67 static void cuda_send_start(cuda_instance_t *);
    68 static void cuda_autopoll_set(cuda_instance_t *, bool);
    69 
    70 static void adb_packet_handle(cuda_instance_t *, uint8_t *, size_t, bool);
     60static void cuda_irq_listen(cuda_t *);
     61static void cuda_irq_receive(cuda_t *);
     62static void cuda_irq_rcv_end(cuda_t *, void *, size_t *);
     63static void cuda_irq_send_start(cuda_t *);
     64static void cuda_irq_send(cuda_t *);
     65
     66static void cuda_packet_handle(cuda_t *, uint8_t *, size_t);
     67static void cuda_send_start(cuda_t *);
     68static void cuda_autopoll_set(cuda_t *, bool);
     69
     70static void adb_packet_handle(cuda_t *, uint8_t *, size_t, bool);
    7171
    7272static irq_pio_range_t cuda_ranges[] = {
    7373        {
    7474                .base = 0,
    75                 .size = sizeof(cuda_t)
     75                .size = sizeof(cuda_regs_t)
    7676        }
    7777};
     
    110110{
    111111        service_id_t service_id;
    112         cuda_instance_t cinst;
     112        cuda_t cinst;
    113113        int rc;
    114114        int i;
    115115
    116116        printf(NAME ": VIA-CUDA Apple Desktop Bus driver\n");
    117        
     117
    118118        for (i = 0; i < ADB_MAX_ADDR; ++i) {
    119119                cinst.adb_dev[i].client_sess = NULL;
     
    145145        cinst.adb_dev[9].service_id = service_id;
    146146
    147         if (cuda_init(&cinst) < 0) {
     147        if (cuda_init(&cinst) != EOK) {
    148148                printf("cuda_init() failed\n");
    149149                return 1;
     
    163163        sysarg_t method;
    164164        service_id_t dsid;
    165         cuda_instance_t *cuda = (cuda_instance_t *) arg;
     165        cuda_t *cuda = (cuda_t *) arg;
    166166        int dev_addr, i;
    167167
     
    187187                callid = async_get_call(&call);
    188188                method = IPC_GET_IMETHOD(call);
    189                
     189
    190190                if (!method) {
    191191                        /* The other side has hung up. */
     
    193193                        return;
    194194                }
    195                
     195
    196196                async_sess_t *sess =
    197197                    async_callback_receive_start(EXCHANGE_SERIALIZE, &call);
     
    199199                        if (cuda->adb_dev[dev_addr].client_sess == NULL) {
    200200                                cuda->adb_dev[dev_addr].client_sess = sess;
    201                                
     201
    202202                                /*
    203203                                 * A hack so that we send the data to the session
     
    208208                                                cuda->adb_dev[i].client_sess = sess;
    209209                                }
    210                                
     210
    211211                                async_answer_0(callid, EOK);
    212212                        } else
     
    217217}
    218218
    219 static int cuda_init(cuda_instance_t *cuda)
    220 {
     219static int cuda_init(cuda_t *cuda)
     220{
     221        int rc;
     222
    221223        if (sysinfo_get_value("cuda.address.physical", &(cuda->cuda_physical)) != EOK)
    222                 return -1;
    223        
     224                return EIO;
     225
    224226        void *vaddr;
    225         if (pio_enable((void *) cuda->cuda_physical, sizeof(cuda_t), &vaddr) != 0)
    226                 return -1;
    227        
     227        rc = pio_enable((void *) cuda->cuda_physical, sizeof(cuda_regs_t),
     228            &vaddr);
     229        if (rc != EOK)
     230                return rc;
     231
    228232        cuda->regs = vaddr;
    229233        cuda->xstate = cx_listen;
     
    237241
    238242        cuda_irq_code.ranges[0].base = (uintptr_t) cuda->cuda_physical;
    239         cuda_irq_code.cmds[0].addr = (void *) &((cuda_t *) cuda->cuda_physical)->ifr;
     243        cuda_irq_code.cmds[0].addr = (void *) &((cuda_regs_t *)
     244            cuda->cuda_physical)->ifr;
    240245        async_irq_subscribe(10, cuda_irq_handler, cuda, &cuda_irq_code);
    241246
     
    247252        cuda_autopoll_set(cuda, true);
    248253
    249         return 0;
     254        return EOK;
    250255}
    251256
     
    253258{
    254259        uint8_t rbuf[CUDA_RCV_BUF_SIZE];
    255         cuda_instance_t *cuda = (cuda_instance_t *)arg;
     260        cuda_t *cuda = (cuda_t *)arg;
    256261        size_t len;
    257262        bool handle;
     
    280285                break;
    281286        }
    282        
     287
    283288        /* Lower IFR.SR_INT so that CUDA can generate next int by raising it. */
    284289        pio_write_8(&cuda->regs->ifr, SR_INT);
     
    297302 * @param cuda CUDA instance
    298303 */
    299 static void cuda_irq_listen(cuda_instance_t *cuda)
     304static void cuda_irq_listen(cuda_t *cuda)
    300305{
    301306        uint8_t b = pio_read_8(&cuda->regs->b);
    302        
     307
    303308        if ((b & TREQ) != 0) {
    304309                printf("cuda_irq_listen: no TREQ?!\n");
    305310                return;
    306311        }
    307        
     312
    308313        pio_write_8(&cuda->regs->b, b & ~TIP);
    309314        cuda->xstate = cx_receive;
     
    316321 * @param cuda CUDA instance
    317322 */
    318 static void cuda_irq_receive(cuda_instance_t *cuda)
     323static void cuda_irq_receive(cuda_t *cuda)
    319324{
    320325        uint8_t data = pio_read_8(&cuda->regs->sr);
    321326        if (cuda->bidx < CUDA_RCV_BUF_SIZE)
    322327                cuda->rcv_buf[cuda->bidx++] = data;
    323        
     328
    324329        uint8_t b = pio_read_8(&cuda->regs->b);
    325        
     330
    326331        if ((b & TREQ) == 0) {
    327332                pio_write_8(&cuda->regs->b, b ^ TACK);
     
    341346 * @param len Place to store length of received packet
    342347 */
    343 static void cuda_irq_rcv_end(cuda_instance_t *cuda, void *buf, size_t *len)
     348static void cuda_irq_rcv_end(cuda_t *cuda, void *buf, size_t *len)
    344349{
    345350        uint8_t b = pio_read_8(&cuda->regs->b);
    346        
     351
    347352        if ((b & TREQ) == 0) {
    348353                cuda->xstate = cx_receive;
     
    352357                cuda_send_start(cuda);
    353358        }
    354        
     359
    355360        memcpy(buf, cuda->rcv_buf, cuda->bidx);
    356361        *len = cuda->bidx;
     
    364369 * @param cuda CUDA instance
    365370 */
    366 static void cuda_irq_send_start(cuda_instance_t *cuda)
     371static void cuda_irq_send_start(cuda_t *cuda)
    367372{
    368373        uint8_t b;
     
    394399 * @param cuda CUDA instance
    395400 */
    396 static void cuda_irq_send(cuda_instance_t *cuda)
     401static void cuda_irq_send(cuda_t *cuda)
    397402{
    398403        if (cuda->bidx < cuda->snd_bytes) {
     
    416421}
    417422
    418 static void cuda_packet_handle(cuda_instance_t *cuda, uint8_t *data, size_t len)
     423static void cuda_packet_handle(cuda_t *cuda, uint8_t *data, size_t len)
    419424{
    420425        if (data[0] != PT_ADB)
     
    426431}
    427432
    428 static void adb_packet_handle(cuda_instance_t *cuda, uint8_t *data,
    429     size_t size, bool autopoll)
     433static void adb_packet_handle(cuda_t *cuda, uint8_t *data, size_t size,
     434    bool autopoll)
    430435{
    431436        uint8_t dev_addr;
     
    466471}
    467472
    468 static void cuda_autopoll_set(cuda_instance_t *cuda, bool enable)
     473static void cuda_autopoll_set(cuda_t *cuda, bool enable)
    469474{
    470475        cuda->snd_buf[0] = PT_CUDA;
     
    477482}
    478483
    479 static void cuda_send_start(cuda_instance_t *cuda)
     484static void cuda_send_start(cuda_t *cuda)
    480485{
    481486        assert(cuda->xstate == cx_listen);
  • uspace/srv/hw/bus/cuda_adb/cuda_adb.h

    r943aaf1b r7e55bed7  
    3939#include <async.h>
    4040#include <fibril_synch.h>
    41 #include <stddef.h>
     41#include <loc.h>
    4242#include <stdint.h>
    4343#include "cuda_hw.h"
     
    6161
    6262typedef struct {
    63         struct cuda *regs;
     63        struct cuda_regs *regs;
    6464        uintptr_t cuda_physical;
    6565
     
    7272
    7373        adb_dev_t adb_dev[ADB_MAX_ADDR];
    74 } cuda_instance_t;
     74} cuda_t;
    7575
    7676#endif
  • uspace/srv/hw/bus/cuda_adb/cuda_hw.h

    r943aaf1b r7e55bed7  
    3939#include <stdint.h>
    4040
    41 typedef struct cuda {
     41typedef struct cuda_regs {
    4242        uint8_t b;
    4343        uint8_t pad0[0x1ff];
     
    8787        uint8_t anh;
    8888        uint8_t pad15[0x1ff];
    89 } cuda_t;
     89} cuda_regs_t;
    9090
    9191/** B register fields */
Note: See TracChangeset for help on using the changeset viewer.