system/wlan/ti/sta_dk_4_0_4_32/pform/linux/src/mmc_tnetw1150_api.c

   1 /* mmc_tnetw1150_api.c
   2  *
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License version 2 as
   5  * published by the Free Software Foundation.
   6  *
   7  * Copyright © Texas Instruments Incorporated (Oct 2005)
   8  * THIS CODE/PROGRAM IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
   9  * EITHER EXPRESS OR IMPLIED, INCLUDED BUT NOT LIMITED TO , THE IMPLIED
  10  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  11  * This program has been modified from its original operation by Texas
  12  * Instruments Incorporated. These changes are covered under version 2
  13  * of the GNU General Public License, dated June 1991.
  14  *
  15  * Copyright © Google Inc (Feb 2008)
  16  */
  17 /*-------------------------------------------------------------------*/
  18 #ifdef TIWLAN_MSM7000
  19
  20 #include <linux/module.h>
  21 #include <linux/kernel.h>
  22 #include <linux/version.h>
  23 #include "mmc_tnetw1150_api.h"
  24 #include <linux/mmc/core.h>
  25
  26 #include <linux/mmc/card.h>
  27 #include <linux/mmc/sdio_func.h>
  28
  29 #define SDIO_INVALID_PERIPHERAL_ADDRESS             0x1FFFF
  30
  31 /* CCCR                                                 0x000000 - 0x0000ff          */
  32 /* Function Basic Register (Function 1)                 0x000100 - 0x0001ff          */
  33         /* 0x101          - Function 1 Extended standard I/O device type code        */
  34         /* 0x102          - RFU[4-0] EnableHighPower Supports High-Power[1-0] SHP[0] */
  35         /* 0x103 - 0x108  - RFU                                                      */
  36         /* 0x109 - 0x10b  - Pointer to Function 1 Card Information Structure         */
  37         /* 0x10c - 0x10e  - Pointer to Function 1 Code Storage Area                  */
  38         /* 0x10f          - Data access window to Function 1 Code Storage Area       */
  39         /* 0x110 - 0x111  - I/O block size for Function 1                            */
  40         /* 0x112 - 0x1ff  - RFU                                                      */
  41 /* Function Basic Register (Function 2)                 0x000200 - 0x0002ff          */
  42 /* Function Basic Register (Function 3)                 0x000300 - 0x0003ff          */
  43 /* Function Basic Register (Function 4)                 0x000400 - 0x0004ff          */
  44 /* Function Basic Register (Function 5)                 0x000500 - 0x0005ff          */
  45 /* Function Basic Register (Function 6)                 0x000600 - 0x0006ff          */
  46 /* Function Basic Register (Function 7)                 0x000700 - 0x0007ff          */
  47 /* RFU                                                  0x000800 - 0x000fff          */
  48 /* CIS common and per-function area                     0x001000 - 0x017fff          */
  49 /* RFU                                                  0x018000 - 0x01ffff          */
  50 #define SDIO_FUNC1_OFFSET    0x1FFC0
  51
  52 typedef struct
  53 {
  54         Peripheral_Address mem_start_addr;
  55         Peripheral_Address mem_part_size;
  56         Peripheral_Address mem_end_addr;
  57         Peripheral_Address reg_start_addr;
  58         Peripheral_Address reg_part_size;
  59         Peripheral_Address reg_end_addr;
  60 } SDIO_TNETW_partitions;
  61 static SDIO_TNETW_partitions TNETW_table;
  62
  63 static SDIO_TNETWConfigParams TNETW_params;
  64
  65 #ifdef CONFIG_MMC_TNET_INFO
  66 typedef struct {
  67         u8  scr_space[SDIO_FUNC1_OFFSET];       /* 0x000000 - 0x01ffbf;
  68                                                    131072B(128kB)-64B=131008B(0x01ffc0) */
  69         u32 amap_size1;                         /* 0x01ffc0 */
  70         u32 amap_offset1;                       /* 0x01ffc4 */
  71         u32 amap_size2;                         /* 0x01ffc8 */
  72         u32 amap_offset2;                       /* 0x01ffcc */
  73         u32 amap_size3;                         /* 0x01ffd0 */
  74         u32 amap_offset3;                       /* 0x01ffd4 */
  75         u32 amap_offset4;                       /* 0x01ffd8 */
  76         u32 cis_offset;                         /* 0x01ffdc - Card Information Structure */
  77         u32 csa_offset;                         /* 0x01ffe0 - Code Storage Area */
  78         u8  filler[16];                         /* 0x01ffe4 - 0x01fff3 */
  79         u32 wr_err_len;                         /* 0x01fff4 */
  80         u32 wr_err_addr;                        /* 0x01fff8 */
  81         u32 status;                             /* 0x01fffc */
  82 } SDIO_FUNC1AddressMap;
  83 SDIO_FUNC1AddressMap mapping;
  84
  85 int sdio_tnetw1150_dump(int count)
  86 {
  87         unsigned long from;
  88         unsigned long br_offset;
  89         unsigned long offset=0;
  90         unsigned long p1_offset=0;
  91         unsigned long p2_offset=0;
  92         struct mmc_request request;
  93         int lines;
  94         int i=0;
  95         int second_part=0;
  96
  97         printk("%s:\n", __FUNCTION__);
  98 #define TNETW1150_OFFSET 1024
  99         from=TNETW1150_OFFSET*count;
 100         if((from+TNETW1150_OFFSET)>(SDIO_FUNC1_OFFSET+64))
 101                 return -1;
 102         br_offset=TNETW1150_OFFSET*count;
 103         if(br_offset>=TNETW_params.map_reg[0].reg_size) {
 104                 second_part=1;
 105                 p2_offset = SDIO_DRIVER_REG_PARTITION_START;
 106                 offset = TNETW_params.map_reg[1].scr_offset - TNETW_params.map_reg[0].reg_size;
 107         }
 108         else {
 109                 p1_offset += SDIO_DOWNLOAD_PARTITION_START;
 110                 offset = TNETW_params.map_reg[0].scr_offset;
 111         }
 112
 113         request.cmd=SD_IO_RW_DIRECT;
 114         request.buffer_len=1;
 115         request.nob=0;
 116         request.block_len=0;
 117         request.buffer=&mapping.scr_space[from];
 118     printk(" TNETW1150 try br_offset:0x%08lx offset:0x%08lx):\n", br_offset, offset);
 119         do {
 120                 request.arg = SDIO_CMD52_READ(0,FUNCTION_SELECT_1,0,br_offset);
 121                 if(__submit_control_request(omap_mmc_dev_get_handle(), &request)!=SDIO_SUCCESS)
 122                         return SDIO_FAILURE;
 123                 udelay(1);
 124                 *request.buffer = (char)omap_readw(OMAP_MMC_RSP6);
 125                 i++;
 126                 request.buffer++;
 127                 br_offset++;
 128         } while(i<TNETW1150_OFFSET);
 129
 130     printk(" TNETW1150 SCR Address Space (start:0x%08lx  end:0x%08lx part:%d offset:0x%08lx):\n", from, from+TNETW1150_OFFSET-1, second_part+1, (!second_part)?p1_offset:p2_offset);
 131
 132         lines=TNETW1150_OFFSET/16;
 133         for(i=0; i<lines;i++, from+=16)
 134         printk("SDIO:0x%04lx(SCR:0x%04lx): %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x\n", from, (!second_part)?(from+p1_offset):(from-p2_offset+SDIO_REG_PARTITION_START), mapping.scr_space[from], mapping.scr_space[from+1], mapping.scr_space[from+2], mapping.scr_space[from+3], mapping.scr_space[from+4], mapping.scr_space[from+5], mapping.scr_space[from+6], mapping.scr_space[from+7], mapping.scr_space[from+8], mapping.scr_space[from+9], mapping.scr_space[from+10], mapping.scr_space[from+11], mapping.scr_space[from+12], mapping.scr_space[from+13], mapping.scr_space[from+14], mapping.scr_space[from+15]);
 135
 136     return 0;
 137 }
 138 EXPORT_SYMBOL(sdio_tnetw1150_dump);
 139
 140 int sdio_tnetw1150_read_proc(char *page, char **start, off_t off, int count, int *eof, void *data)
 141 {
 142     int len=0;
 143         int br_offset = SDIO_FUNC1_OFFSET;
 144         struct mmc_request request;
 145         u8 buf[64];
 146         u8 buf3[3];
 147         int bytes_to_read=64;
 148         int i;
 149 #define CCCR_SIZE 17
 150         u8 buf_ccr[CCCR_SIZE];
 151         u8 buf_ccr_offset[CCCR_SIZE] = {
 152                 CCCR_SDIO_REVISION, CCCR_SD_SPECIFICATION_REVISION, CCCR_IO_ENABLE,
 153                 CCCR_IO_READY, CCCR_INT_ENABLE, CCCR_INT_PENDING,
 154                 CCCR_IO_ABORT, CCCR_BUS_INTERFACE_CONTOROL, CCCR_CARD_CAPABILITY,
 155                 CCCR_COMMON_CIS_POINTER, CCCR_COMMON_CIS_POINTER+1, CCCR_COMMON_CIS_POINTER+2,
 156                 CCCR_BUS_SUSPEND, CCCR_FUNCTION_SELECT, CCCR_EXEC_FLAGS,
 157                 CCCR_READY_FLAGS, CCCR_FNO_BLOCK_SIZE,
 158         };
 159 #define FBR_SIZE 9
 160         u8 buf_fbr[FBR_SIZE];
 161         u16 buf_fbr_offset[FBR_SIZE] = {
 162                 FBR_PTR_F1_CIS, FBR_PTR_F1_CIS+1, FBR_PTR_F1_CIS+2,
 163                 FBR_PTR_F1_CSA, FBR_PTR_F1_CSA+1, FBR_PTR_F1_CSA+2,
 164                 FBR_WIN_F1_CSA, FBR_F1_IO_BLK_SIZE, FBR_F1_IO_BLK_SIZE+1,
 165         };
 166
 167         request.cmd=SD_IO_RW_DIRECT;
 168         request.buffer_len=1;
 169         request.nob=0;
 170         request.block_len=0;
 171         request.buffer=&buf[0];
 172         for (i=0; i<bytes_to_read;i++,request.buffer++,br_offset++) {
 173                 request.arg = SDIO_CMD52_READ(0,FUNCTION_SELECT_1,0,br_offset);
 174                 if(__submit_control_request(omap_mmc_dev_get_handle(), &request)!=SDIO_SUCCESS)
 175                         return SDIO_FAILURE;
 176                 *request.buffer = (char)omap_readw(OMAP_MMC_RSP6);
 177         }
 178         memcpy(&mapping.amap_size1, &buf, 64);
 179
 180     count -= 80; /* some reserve */
 181     len += (len<count)?sprintf(page+len, " TNETW1150 partitions:\n"):0;
 182     len += (len<count)?sprintf(page+len, " Memory:      "):0;
 183         len += (len<count)?sprintf(page+len, " start:0x%08lx  end:0x%08lx  size:0x%08lx bytes\n", TNETW_table.mem_start_addr, TNETW_table.mem_end_addr, TNETW_table.mem_part_size):0;
 184     len += (len<count)?sprintf(page+len, " Registers:   "):0;
 185         len += (len<count)?sprintf(page+len, " start:0x%08lx  end:0x%08lx  size:0x%08lx bytes\n", TNETW_table.reg_start_addr, TNETW_table.reg_end_addr, TNETW_table.reg_part_size):0;
 186
 187     len += (len<count)?sprintf(page+len, " SDIO Function 1 Address Map:\n"):0;
 188         len += (len<count)?sprintf(page+len, " amap_size1:0x%08x  amap_offset1:0x%08x\n", mapping.amap_size1, mapping.amap_offset1):0;
 189         len += (len<count)?sprintf(page+len, " amap_size2:0x%08x  amap_offset2:0x%08x\n", mapping.amap_size2, mapping.amap_offset2):0;
 190         len += (len<count)?sprintf(page+len, " amap_size3:0x%08x  amap_offset3:0x%08x\n", mapping.amap_size3, mapping.amap_offset3):0;
 191         len += (len<count)?sprintf(page+len, "                        amap_offset4:0x%08x\n", mapping.amap_offset4):0;
 192         len += (len<count)?sprintf(page+len, " cis_offset:0x%08x  csa_offset  :0x%08x\n", mapping.cis_offset, mapping.csa_offset):0;
 193         len += (len<count)?sprintf(page+len, " wr_err_len:0x%08x  wr_err_addr :0x%08x\n", mapping.wr_err_len, mapping.wr_err_addr):0;
 194         len += (len<count)?sprintf(page+len, " status    :0x%08x\n", mapping.status):0;
 195
 196         request.cmd=SD_IO_RW_DIRECT;
 197         request.buffer_len=1;
 198         request.nob=0;
 199         request.block_len=0;
 200         request.buffer=&buf_ccr[0];
 201         for (i=0; i<CCCR_SIZE;i++,request.buffer++) {
 202                 request.arg = SDIO_CMD52_READ(0,FUNCTION_SELECT_0,0,buf_ccr_offset[i]);
 203                 if(__submit_control_request(omap_mmc_dev_get_handle(), &request)!=SDIO_SUCCESS)
 204                         return SDIO_FAILURE;
 205                 *request.buffer = (char)omap_readw(OMAP_MMC_RSP6);
 206         }
 207
 208     len += (len<count)?sprintf(page+len, "\n Card Common Control Registers:\n"):0;
 209         len += (len<count)?sprintf(page+len, " \
 210  REVISION             :0x%02x  SD_SPEC_REVISION       :0x%02x   IO_ENABLE            :0x%02x\n \
 211  IO_READY             :0x%02x  INT_ENABLE             :0x%02x   INT_PENDING          :0x%02x\n \
 212  IO_ABORT             :0x%02x  BUS_INTERFACE_CONTOROL :0x%02x   CARD_CAPABILITY      :0x%02x\n \
 213  COMMON_CIS_POINTER[2]:0x%02x  COMMON_CIS_POINTER[1]  :0x%02x   COMMON_CIS_POINTER[0]:0x%02x\n \
 214  BUS_SUSPEND          :0x%02x  FUNCTION_SELECT        :0x%02x   EXEC_FLAGS           :0x%02x\n \
 215  READY_FLAGS          :0x%02x  FNO_BLOCK_SIZE         :0x%02x\n" , buf_ccr[0], buf_ccr[1], buf_ccr[2], buf_ccr[3], buf_ccr[4], buf_ccr[5], buf_ccr[6], buf_ccr[7], buf_ccr[8], buf_ccr[11], buf_ccr[10], buf_ccr[9], buf_ccr[12], buf_ccr[13], buf_ccr[14], buf_ccr[15], buf_ccr[16]):0;
 216
 217         request.cmd=SD_IO_RW_DIRECT;
 218         request.buffer_len=1;
 219         request.nob=0;
 220         request.block_len=0;
 221
 222         request.buffer=&buf3[0];
 223         for (i=0; i<3;i++,request.buffer++) {
 224                 request.arg = SDIO_CMD52_READ(0,FUNCTION_SELECT_1,0,FBR_PTR_F1_IO_DEV);
 225                 if(__submit_control_request(omap_mmc_dev_get_handle(), &request)!=SDIO_SUCCESS)
 226                         return SDIO_FAILURE;
 227                 *request.buffer = (char)omap_readw(OMAP_MMC_RSP6);
 228         }
 229
 230         request.buffer=&buf_fbr[0];
 231         for (i=0; i<FBR_SIZE;i++,request.buffer++) {
 232                 request.arg = SDIO_CMD52_READ(0,FUNCTION_SELECT_1,0,buf_fbr_offset[i]);
 233                 if(__submit_control_request(omap_mmc_dev_get_handle(), &request)!=SDIO_SUCCESS)
 234                         return SDIO_FAILURE;
 235                 *request.buffer = (char)omap_readw(OMAP_MMC_RSP6);
 236         }
 237
 238     len += (len<count)?sprintf(page+len, "\n Function Basic Registers(Func 1):\n"):0;
 239         len += (len<count)?sprintf(page+len, " \
 240  Func 1 CSA enable and CSA support              :     0x%02x 0x%02x\n \
 241  Func 1 Ext stand. I/O device i/f and type code :     0x%02x 0x%02x\n \
 242  EHP|SHP[1]|SHP[0]                              :          0x%02x\n \
 243  Pointer to Func 1 Card Information Structure   :0x%02x 0x%02x 0x%02x\n \
 244  Pointer to Func 1 Code Storage Area            :0x%02x 0x%02x 0x%02x\n \
 245  Data access window to Func 1 Code Storage Area :          0x%02x\n \
 246  I/O block size for Func 1                      :     0x%02x 0x%02x\n", ((buf3[0]&0x80)>>7), ((buf3[0]&0x40)>>6), (buf3[1]&0x0f), buf3[1], (buf3[2]&0x07), buf_fbr[2], buf_fbr[1], buf_fbr[0], buf_fbr[5], buf_fbr[4], buf_fbr[3], buf_fbr[6], buf_fbr[8], buf_fbr[7]):0;
 247
 248     *eof = 1;
 249     return len;
 250 }
 251 #endif /*CONFIG_MMC_TNET_STATISTICS*/
 252
 253
 254 /*
 255   Initialization of TNETW memory configuration.
 256 */
 257 extern int debug_level;
 258 SDIO_Status SDIO_TNETWInit(SDIO_TNETWConfigParams *params)
 259 {
 260     /*  debug_level=3;    */
 261         /* printk("%s\n", __FUNCTION__); */
 262
 263         memset(&TNETW_params, 0, sizeof(SDIO_TNETWConfigParams));
 264
 265     if(!params) {
 266                 /* printk("%s set to default\n", __FUNCTION__); */
 267                 /* set to default value in case params is not presented */
 268                 TNETW_params.num_of_parts = 2;
 269                 /* First time initialization */
 270                 TNETW_params.map_reg[0].reg_size = SDIO_DOWNLOAD_PARTITION_SIZE;
 271                 TNETW_params.map_reg[0].scr_offset = SDIO_DOWNLOAD_PARTITION_START;
 272                 /* After firmware has been downloaded, data memory region
 273                    has to be re-initialized as following:
 274                 TNETW_params.map_reg[0].reg_size = SDIO_MEM_PARTITION_START;
 275                 TNETW_params.map_reg[0].scr_offset = SDIO_MEM_PARTITION_SIZE;
 276                 */
 277                 TNETW_params.map_reg[1].reg_size = SDIO_REG_PARTITION_SIZE;
 278                 TNETW_params.map_reg[1].scr_offset = SDIO_REG_PARTITION_START;
 279         }
 280         else {
 281                 /* printk("%s: params->num_of_parts=%d\n", __FUNCTION__, params->num_of_parts); */
 282                 /* validate input parameters */
 283                 switch(params->num_of_parts) {
 284                 case 1:
 285                         if(params->map_reg[0].reg_size > AMAP_ONE_REGION)
 286                                 return SDIO_FAILURE;
 287                         break;
 288                 case 2:
 289                         if((params->map_reg[0].reg_size + params->map_reg[1].reg_size) > AMAP_ONE_REGION)
 290                                 return SDIO_FAILURE;
 291                         break;
 292                 case 3:
 293                         if((params->map_reg[0].reg_size + params->map_reg[1].reg_size + params->map_reg[2].reg_size) > AMAP_ONE_REGION)
 294                                 return SDIO_FAILURE;
 295                         break;
 296                 case 4:
 297                         if((params->map_reg[0].reg_size + params->map_reg[1].reg_size + params->map_reg[2].reg_size + params->map_reg[3].reg_size) > AMAP_ONE_REGION)
 298                                 return SDIO_FAILURE;
 299                         break;
 300                 default:
 301                         return SDIO_FAILURE;
 302                 }
 303                 memcpy(&TNETW_params, params, sizeof(SDIO_TNETWConfigParams));
 304         }
 305
 306 #ifdef CONFIG_PROC_FS
 307 #ifdef CONFIG_MMC_TNET_INFO
 308         create_proc_read_entry("sdio_tnetw1150", 0, NULL, sdio_tnetw1150_read_proc, NULL);
 309 #endif
 310 #endif
 311
 312         /* printk("%s completed\n", __FUNCTION__); */
 313
 314         return SDIO_SUCCESS;
 315 }
 316
 317 SDIO_Status SDIO_TNETWReset(SDIO_TNETWConfigParams *params)
 318 {
 319         /* printk("%s\n", __FUNCTION__); */
 320
 321         memset(&TNETW_params, 0, sizeof(SDIO_TNETWConfigParams));
 322
 323         if(!params) {
 324                 /* printk("%s set to default\n", __FUNCTION__); */
 325                 /* set to default value in case params is not presented */
 326                 TNETW_params.num_of_parts = 2;
 327
 328                 /* After firmware has been downloaded, data memory region
 329                    has to be re-initialized as following */
 330                 TNETW_params.map_reg[0].reg_size = SDIO_MEM_PARTITION_START;
 331                 TNETW_params.map_reg[0].scr_offset = SDIO_MEM_PARTITION_SIZE;
 332                 TNETW_params.map_reg[1].reg_size = SDIO_REG_PARTITION_SIZE;
 333                 TNETW_params.map_reg[1].scr_offset = SDIO_REG_PARTITION_START;
 334         }
 335         else {
 336                 /* printk("%s: params->num_of_parts=%d\n", __FUNCTION__, params->num_of_parts); */
 337                 /* validate input parameters */
 338                 switch(params->num_of_parts) {
 339                 case 1:
 340                         if(params->map_reg[0].reg_size > AMAP_ONE_REGION)
 341                                 return SDIO_FAILURE;
 342                         break;
 343                 case 2:
 344                         if((params->map_reg[0].reg_size + params->map_reg[1].reg_size) > AMAP_ONE_REGION)
 345                                 return SDIO_FAILURE;
 346                         break;
 347                 case 3:
 348                         if((params->map_reg[0].reg_size + params->map_reg[1].reg_size + params->map_reg[2].reg_size) > AMAP_ONE_REGION)
 349                                 return SDIO_FAILURE;
 350                         break;
 351                 case 4:
 352                         if((params->map_reg[0].reg_size + params->map_reg[1].reg_size + params->map_reg[2].reg_size + params->map_reg[3].reg_size) > AMAP_ONE_REGION)
 353                                 return SDIO_FAILURE;
 354                         break;
 355                 default:
 356                         return SDIO_FAILURE;
 357                 }
 358                 memcpy(&TNETW_params, params, sizeof(SDIO_TNETWConfigParams));
 359         }
 360
 361         /* printk("%s completed\n", __FUNCTION__); */
 362
 363         return SDIO_SUCCESS;
 364 }
 365
 366
 367 static SDIO_Status config_partition(SDIO_Handle sdioHandle, int partition_no, Peripheral_Address start_addr, SDIO_BufferLength part_size)
 368 {
 369         struct sdio_func *func = (struct sdio_func *) sdioHandle;
 370         u8 data;
 371         int br_offset = SDIO_FUNC1_OFFSET + (partition_no-1)*8;
 372         int i, rc;
 373
 374         /* printk("%s: partition_no=%d\n", __FUNCTION__, partition_no); */
 375
 376         /* Set size - write out 4 bytes by 4 requests */
 377         if (partition_no < AMAP_MAX_REGIONS)
 378         {
 379                 for(i=0;i<4;i++,br_offset++) {
 380                         data = (part_size>>(8*i))&0xFF;
 381
 382                         /* put R/W Flag (1 for write); Function Number(1), RAW Flag(0),
 383                            Register Address - the address of the byte of data inside
 384                            of the selected function that will be written
 385                            (br_offset for func1),
 386                            Write Data - for a direct write command, this is the byte=data,
 387                            that will be written to the selected address=br_offset).
 388                         */
 389                         sdio_writeb(func, data, br_offset, &rc);
 390                         if (rc < 0) {
 391                                 printk(KERN_ERR "%s: Error writing size\n", __FUNCTION__);
 392                                 return SDIO_FAILURE;
 393                         }
 394             /* printk("%s: offset byte=%d data=0x%08x at=0x%08x\n", __FUNCTION__, i, data, br_offset); */
 395                 }
 396
 397         /* Set offset - write out 4 bytes by 4 requests */
 398         for(i=0;i<4;i++,br_offset++) {
 399             data = (start_addr>>(8*i))&0xFF;
 400             sdio_writeb(func, data, br_offset, &rc);
 401             if (rc < 0) {
 402                 printk(KERN_ERR "%s: Error writing offset\n", __FUNCTION__);
 403                 return SDIO_FAILURE;
 404             }
 405             /* printk("%s: offset byte=%d data=0x%08x at=0x%08x\n", __FUNCTION__, i, data, br_offset); */
 406         }
 407     }
 408 #if 0
 409     if( partition_no == 2 ) {
 410         unsigned long id1;
 411         for(i=0,br_offset=0x1ce34;i<4;i++,br_offset++) {
 412             data = sdio_readb(func, br_offset, &rc);
 413             if (rc < 0) {
 414                 printk(KERN_ERR "%s: Error reading offset\n", __FUNCTION__);
 415                 return SDIO_FAILURE;
 416             }
 417             printk("%s: offset byte=%d data=0x%08x at=0x%08x\n", __FUNCTION__, i, data, br_offset);
 418         }
 419         rc = sdio_memcpy_fromio(func, &id1, 0x1ce34, 4); /* Dm: Important - DO NOT REMOVE !!! */
 420         if (rc < 0) {
 421             printk(KERN_ERR "%s: Error reading offset\n", __FUNCTION__);
 422             return SDIO_FAILURE;
 423         }
 424         printk("%s: data=0x%08x at=0x%08x\n", __FUNCTION__, id1, br_offset);
 425     }
 426 #endif
 427     return SDIO_SUCCESS;
 428 }
 429
 430 /*
 431   This function configures the slave SDIO device for the required
 432   operation mode.
 433 */
 434 SDIO_Status SDIO_TNETWConfig(SDIO_Handle sdioHandle, Peripheral_ConfigParams **peripheral_info)
 435 {
 436         SDIO_Status rc;
 437
 438         /* printk("%s\n", __FUNCTION__); */
 439
 440         TNETW_table.mem_start_addr = TNETW_params.map_reg[0].scr_offset;
 441         TNETW_table.mem_part_size = TNETW_params.map_reg[0].reg_size;
 442         TNETW_table.mem_end_addr = TNETW_table.mem_start_addr + TNETW_table.mem_part_size - 1;
 443
 444         TNETW_table.reg_start_addr = TNETW_params.map_reg[1].scr_offset;
 445         TNETW_table.reg_part_size = TNETW_params.map_reg[1].reg_size;
 446         TNETW_table.reg_end_addr = TNETW_table.reg_start_addr + TNETW_table.reg_part_size - 1;
 447 #if 0
 448         printk("%s: memory area: start_addr=0x%08lx end_addr=0x%08lx part_size=0x%08lx\n", __FUNCTION__, TNETW_table.mem_start_addr, TNETW_table.mem_end_addr, TNETW_table.mem_part_size);
 449         printk("%s: register area: start_addr=0x%08lx end_addr=0x%08lx part_size=0x%08lx\n", __FUNCTION__, TNETW_table.reg_start_addr, TNETW_table.reg_end_addr, TNETW_table.reg_part_size);
 450 #endif
 451         /* Configure 17-bits address range in peripheral */
 452         rc=config_partition(sdioHandle, 1, TNETW_table.mem_start_addr, TNETW_table.mem_part_size);
 453         rc = (rc==SDIO_SUCCESS)?config_partition(sdioHandle, 2, TNETW_table.reg_start_addr, TNETW_table.reg_part_size):rc;
 454
 455         if(*peripheral_info)
 456                 *peripheral_info = (void *)&TNETW_table;
 457
 458     /* printk("%s: TNETW1150 partitions:\n", __FUNCTION__);
 459         printk("Memory   : start:0x%08lx  end:0x%08lx  size:0x%08lx bytes\n", TNETW_table.mem_start_addr, TNETW_table.mem_end_addr, TNETW_table.mem_part_size);
 460         printk("Registers: start:0x%08lx  end:0x%08lx  size:0x%08lx bytes\n", TNETW_table.reg_start_addr, TNETW_table.reg_end_addr, TNETW_table.reg_part_size);
 461     */
 462
 463         return rc;
 464 }
 465
 466 /*
 467   This function performs convertion of peripheral adddress into 17 bits
 468   SDIO address. If found that the memory partition configuration must be
 469   changed, the memory is re-mapped in accordance to requested address.
 470 */
 471 SDIO_Address SDIO_ConvertTNETWToSDIOMaster(Peripheral_Address in_tnetw_address, SDIO_BufferLength packet_size)
 472 {
 473         SDIO_Address out_sdio_address;
 474
 475 #ifdef CONFIG_SDIO_ADDRESS_MAPPING_BY_APPLICATION
 476         out_sdio_address = in_tnetw_address;
 477 #else
 478         Peripheral_Address tnetw_last_address = in_tnetw_address + packet_size - 1;
 479
 480         /* printk("%s:\n", __FUNCTION__); */
 481
 482         if ((in_tnetw_address >= TNETW_table.mem_start_addr) && (tnetw_last_address <= TNETW_table.mem_end_addr)) {
 483                 /* printk("%s part1 from=0x%08lx to 0x%08lx\n", __FUNCTION__, in_tnetw_address, tnetw_last_address); */
 484                 /* address in the 1-st partition range (data memory space) */
 485                 out_sdio_address = in_tnetw_address - TNETW_table.mem_start_addr;
 486         }
 487         else if ((in_tnetw_address >= TNETW_table.reg_start_addr) && (tnetw_last_address <= TNETW_table.reg_end_addr)) {
 488                 /* printk("%s part2 from=0x%08lx to 0x%08lx\n", __FUNCTION__, in_tnetw_address, tnetw_last_address); */
 489                 /* address in the 2-nd partition range (register memory space) */
 490                 out_sdio_address = in_tnetw_address - TNETW_table.reg_start_addr + TNETW_table.mem_part_size;
 491         }
 492         else {
 493                 /* printk("%s peripheral addresses from=0x%08lx to 0x%08lx is out of range\n", __FUNCTION__, in_tnetw_address, tnetw_last_address); */
 494                 /* invalid address */
 495                 return SDIO_INVALID_PERIPHERAL_ADDRESS;
 496         }
 497         /* printk("%s: in_tnetw_addr=0x%08lx out_sdio_addr=0x%08lx\n", __FUNCTION__, in_tnetw_address, out_sdio_address); */
 498
 499 #endif /* CONFIG_SDIO_ADDRESS_MAPPING_BY_APPLICATION */
 500
 501         return out_sdio_address;
 502 }
 503
 504 SDIO_Status SDIO_TNETW_Set_ELP_Reg(SDIO_Handle sdioHandle, Peripheral_Address start_addr, unsigned int data)
 505 {
 506         struct sdio_func *func = (struct sdio_func *) sdioHandle;
 507         u8 data1 = 0;
 508         int br_offset = start_addr;
 509         int i, rc;
 510
 511         /* Set size - write out 4 bytes by 4 requests */
 512         for(i=0;i<1;i++,br_offset++) {
 513                 data1 = (data>>(8*i))&0xFF;
 514
 515                 /* put R/W Flag (1 for write); Function Number(1), RAW Flag(0),
 516                            Register Address - the address of the byte of data inside
 517                            of the selected function that will be written
 518                            (br_offset for func1),
 519                            Write Data - for a direct write command, this is the byte=data,
 520                            that will be written to the selected address=br_offset).
 521                 */
 522                 sdio_writeb(func, data1, br_offset, &rc);
 523                 if (rc < 0) {
 524                         printk(KERN_ERR "%s: Error writing size\n", __FUNCTION__);
 525                         return SDIO_FAILURE;
 526                 }
 527         }
 528         return SDIO_SUCCESS;
 529 }
 530
 531 SDIO_Status SDIO_TNETW_Get_ELP_Reg(SDIO_Handle sdioHandle, Peripheral_Address start_addr, unsigned int *data)
 532 {
 533         struct sdio_func *func = (struct sdio_func *) sdioHandle;
 534         int br_offset = start_addr;
 535         int rc;
 536
 537         *(u8*)data = sdio_readb_ext(func, br_offset, &rc, 0x01);
 538         if (rc) {
 539                 printk(KERN_ERR "%s: Error reading sdio register (%d)\n", __FUNCTION__, rc);
 540                 return SDIO_FAILURE;
 541         }
 542         return SDIO_SUCCESS;
 543 }
 544
 545 #endif /* TIWLAN_MSM7000 */