![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bulkmem.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / pcmcia-cs / modules|
Return to bulkmem.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / pcmcia-cs / modules |
1.1 ! root 1: /*====================================================================== ! 2: ! 3: PCMCIA Bulk Memory Services ! 4: ! 5: bulkmem.c 1.44 2002/06/29 06:23:09 ! 6: ! 7: The contents of this file are subject to the Mozilla Public ! 8: License Version 1.1 (the "License"); you may not use this file ! 9: except in compliance with the License. You may obtain a copy of ! 10: the License at http://www.mozilla.org/MPL/ ! 11: ! 12: Software distributed under the License is distributed on an "AS ! 13: IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or ! 14: implied. See the License for the specific language governing ! 15: rights and limitations under the License. ! 16: ! 17: The initial developer of the original code is David A. Hinds ! 18: <[email protected]>. Portions created by David A. Hinds ! 19: are Copyright (C) 1999 David A. Hinds. All Rights Reserved. ! 20: ! 21: Alternatively, the contents of this file may be used under the ! 22: terms of the GNU General Public License version 2 (the "GPL"), in ! 23: which case the provisions of the GPL are applicable instead of the ! 24: above. If you wish to allow the use of your version of this file ! 25: only under the terms of the GPL and not to allow others to use ! 26: your version of this file under the MPL, indicate your decision ! 27: by deleting the provisions above and replace them with the notice ! 28: and other provisions required by the GPL. If you do not delete ! 29: the provisions above, a recipient may use your version of this ! 30: file under either the MPL or the GPL. ! 31: ! 32: ======================================================================*/ ! 33: ! 34: #define __NO_VERSION__ ! 35: ! 36: #include <linux/module.h> ! 37: #include <linux/kernel.h> ! 38: #include <linux/string.h> ! 39: #include <linux/errno.h> ! 40: #include <linux/slab.h> ! 41: #include <linux/mm.h> ! 42: #include <linux/sched.h> ! 43: #include <linux/timer.h> ! 44: ! 45: #define IN_CARD_SERVICES ! 46: #include <pcmcia/cs_types.h> ! 47: #include <pcmcia/ss.h> ! 48: #include <pcmcia/cs.h> ! 49: #include <pcmcia/bulkmem.h> ! 50: #include <pcmcia/cistpl.h> ! 51: #include "cs_internal.h" ! 52: ! 53: /*====================================================================== ! 54: ! 55: This function handles submitting an MTD request, and retrying ! 56: requests when an MTD is busy. ! 57: ! 58: An MTD request should never block. ! 59: ! 60: ======================================================================*/ ! 61: ! 62: static int do_mtd_request(memory_handle_t handle, mtd_request_t *req, ! 63: caddr_t buf) ! 64: { ! 65: int ret, tries; ! 66: client_t *mtd; ! 67: socket_info_t *s; ! 68: ! 69: mtd = handle->mtd; ! 70: if (mtd == NULL) ! 71: return CS_GENERAL_FAILURE; ! 72: s = SOCKET(mtd); ! 73: for (ret = tries = 0; tries < 100; tries++) { ! 74: mtd->event_callback_args.mtdrequest = req; ! 75: mtd->event_callback_args.buffer = buf; ! 76: ret = EVENT(mtd, CS_EVENT_MTD_REQUEST, CS_EVENT_PRI_LOW); ! 77: if (ret != CS_BUSY) ! 78: break; ! 79: switch (req->Status) { ! 80: case MTD_WAITREQ: ! 81: /* Not that we should ever need this... */ ! 82: interruptible_sleep_on_timeout(&mtd->mtd_req, HZ); ! 83: break; ! 84: case MTD_WAITTIMER: ! 85: case MTD_WAITRDY: ! 86: interruptible_sleep_on_timeout(&mtd->mtd_req, ! 87: req->Timeout*HZ/1000); ! 88: req->Function |= MTD_REQ_TIMEOUT; ! 89: break; ! 90: case MTD_WAITPOWER: ! 91: interruptible_sleep_on(&mtd->mtd_req); ! 92: break; ! 93: } ! 94: if (signal_pending(current)) ! 95: printk(KERN_NOTICE "cs: do_mtd_request interrupted!\n"); ! 96: } ! 97: if (tries == 20) { ! 98: printk(KERN_NOTICE "cs: MTD request timed out!\n"); ! 99: ret = CS_GENERAL_FAILURE; ! 100: } ! 101: wake_up_interruptible(&mtd->mtd_req); ! 102: retry_erase_list(&mtd->erase_busy, 0); ! 103: return ret; ! 104: } /* do_mtd_request */ ! 105: ! 106: /*====================================================================== ! 107: ! 108: This stuff is all for handling asynchronous erase requests. It ! 109: is complicated because all the retry stuff has to be dealt with ! 110: in timer interrupts or in the card status event handler. ! 111: ! 112: ======================================================================*/ ! 113: ! 114: static void insert_queue(erase_busy_t *head, erase_busy_t *entry) ! 115: { ! 116: DEBUG(2, "cs: adding 0x%p to queue 0x%p\n", entry, head); ! 117: entry->next = head; ! 118: entry->prev = head->prev; ! 119: head->prev->next = entry; ! 120: head->prev = entry; ! 121: } ! 122: ! 123: static void remove_queue(erase_busy_t *entry) ! 124: { ! 125: DEBUG(2, "cs: unqueueing 0x%p\n", entry); ! 126: entry->next->prev = entry->prev; ! 127: entry->prev->next = entry->next; ! 128: } ! 129: ! 130: static void retry_erase(erase_busy_t *busy, u_int cause) ! 131: { ! 132: eraseq_entry_t *erase = busy->erase; ! 133: mtd_request_t req; ! 134: client_t *mtd; ! 135: socket_info_t *s; ! 136: int ret; ! 137: ! 138: DEBUG(2, "cs: trying erase request 0x%p...\n", busy); ! 139: if (busy->next) ! 140: remove_queue(busy); ! 141: req.Function = MTD_REQ_ERASE | cause; ! 142: req.TransferLength = erase->Size; ! 143: req.DestCardOffset = erase->Offset + erase->Handle->info.CardOffset; ! 144: req.MediaID = erase->Handle->MediaID; ! 145: mtd = erase->Handle->mtd; ! 146: s = SOCKET(mtd); ! 147: mtd->event_callback_args.mtdrequest = &req; ! 148: ret = EVENT(mtd, CS_EVENT_MTD_REQUEST, CS_EVENT_PRI_LOW); ! 149: if (ret == CS_BUSY) { ! 150: DEBUG(2, " Status = %d, requeueing.\n", req.Status); ! 151: switch (req.Status) { ! 152: case MTD_WAITREQ: ! 153: case MTD_WAITPOWER: ! 154: insert_queue(&mtd->erase_busy, busy); ! 155: break; ! 156: case MTD_WAITTIMER: ! 157: case MTD_WAITRDY: ! 158: if (req.Status == MTD_WAITRDY) ! 159: insert_queue(&s->erase_busy, busy); ! 160: mod_timer(&busy->timeout, jiffies + req.Timeout*HZ/1000); ! 161: break; ! 162: } ! 163: } else { ! 164: /* update erase queue status */ ! 165: DEBUG(2, " Ret = %d\n", ret); ! 166: switch (ret) { ! 167: case CS_SUCCESS: ! 168: erase->State = ERASE_PASSED; break; ! 169: case CS_WRITE_PROTECTED: ! 170: erase->State = ERASE_MEDIA_WRPROT; break; ! 171: case CS_BAD_OFFSET: ! 172: erase->State = ERASE_BAD_OFFSET; break; ! 173: case CS_BAD_SIZE: ! 174: erase->State = ERASE_BAD_SIZE; break; ! 175: case CS_NO_CARD: ! 176: erase->State = ERASE_BAD_SOCKET; break; ! 177: default: ! 178: erase->State = ERASE_FAILED; break; ! 179: } ! 180: busy->client->event_callback_args.info = erase; ! 181: EVENT(busy->client, CS_EVENT_ERASE_COMPLETE, CS_EVENT_PRI_LOW); ! 182: kfree(busy); ! 183: /* Resubmit anything waiting for a request to finish */ ! 184: wake_up_interruptible(&mtd->mtd_req); ! 185: retry_erase_list(&mtd->erase_busy, 0); ! 186: } ! 187: } /* retry_erase */ ! 188: ! 189: void retry_erase_list(erase_busy_t *list, u_int cause) ! 190: { ! 191: erase_busy_t tmp = *list; ! 192: ! 193: DEBUG(2, "cs: rescanning erase queue list 0x%p\n", list); ! 194: if (list->next == list) ! 195: return; ! 196: /* First, truncate the original list */ ! 197: list->prev->next = &tmp; ! 198: list->next->prev = &tmp; ! 199: list->prev = list->next = list; ! 200: tmp.prev->next = &tmp; ! 201: tmp.next->prev = &tmp; ! 202: ! 203: /* Now, retry each request, in order. */ ! 204: while (tmp.next != &tmp) ! 205: retry_erase(tmp.next, cause); ! 206: } /* retry_erase_list */ ! 207: ! 208: static void handle_erase_timeout(u_long arg) ! 209: { ! 210: DEBUG(0, "cs: erase timeout for entry 0x%lx\n", arg); ! 211: retry_erase((erase_busy_t *)arg, MTD_REQ_TIMEOUT); ! 212: } ! 213: ! 214: static void setup_erase_request(client_handle_t handle, eraseq_entry_t *erase) ! 215: { ! 216: erase_busy_t *busy; ! 217: region_info_t *info; ! 218: ! 219: if (CHECK_REGION(erase->Handle)) ! 220: erase->State = ERASE_BAD_SOCKET; ! 221: else { ! 222: info = &erase->Handle->info; ! 223: if ((erase->Offset >= info->RegionSize) || ! 224: (erase->Offset & (info->BlockSize-1))) ! 225: erase->State = ERASE_BAD_OFFSET; ! 226: else if ((erase->Offset+erase->Size > info->RegionSize) || ! 227: (erase->Size & (info->BlockSize-1))) ! 228: erase->State = ERASE_BAD_SIZE; ! 229: else { ! 230: erase->State = 1; ! 231: busy = kmalloc(sizeof(erase_busy_t), GFP_KERNEL); ! 232: busy->erase = erase; ! 233: busy->client = handle; ! 234: init_timer(&busy->timeout); ! 235: busy->timeout.data = (u_long)busy; ! 236: busy->timeout.function = &handle_erase_timeout; ! 237: busy->prev = busy->next = NULL; ! 238: retry_erase(busy, 0); ! 239: } ! 240: } ! 241: } /* setup_erase_request */ ! 242: ! 243: /*====================================================================== ! 244: ! 245: MTD helper functions ! 246: ! 247: ======================================================================*/ ! 248: ! 249: static int mtd_modify_window(window_handle_t win, mtd_mod_win_t *req) ! 250: { ! 251: if ((win == NULL) || (win->magic != WINDOW_MAGIC)) ! 252: return CS_BAD_HANDLE; ! 253: win->ctl.flags = MAP_16BIT | MAP_ACTIVE; ! 254: if (req->Attributes & WIN_USE_WAIT) ! 255: win->ctl.flags |= MAP_USE_WAIT; ! 256: if (req->Attributes & WIN_MEMORY_TYPE) ! 257: win->ctl.flags |= MAP_ATTRIB; ! 258: win->ctl.speed = req->AccessSpeed; ! 259: win->ctl.card_start = req->CardOffset; ! 260: win->sock->ss_entry(win->sock->sock, SS_SetMemMap, &win->ctl); ! 261: return CS_SUCCESS; ! 262: } ! 263: ! 264: static int mtd_set_vpp(client_handle_t handle, mtd_vpp_req_t *req) ! 265: { ! 266: socket_info_t *s; ! 267: if (CHECK_HANDLE(handle)) ! 268: return CS_BAD_HANDLE; ! 269: if (req->Vpp1 != req->Vpp2) ! 270: return CS_BAD_VPP; ! 271: s = SOCKET(handle); ! 272: s->socket.Vpp = req->Vpp1; ! 273: if (s->ss_entry(s->sock, SS_SetSocket, &s->socket)) ! 274: return CS_BAD_VPP; ! 275: return CS_SUCCESS; ! 276: } ! 277: ! 278: static int mtd_rdy_mask(client_handle_t handle, mtd_rdy_req_t *req) ! 279: { ! 280: socket_info_t *s; ! 281: if (CHECK_HANDLE(handle)) ! 282: return CS_BAD_HANDLE; ! 283: s = SOCKET(handle); ! 284: if (req->Mask & CS_EVENT_READY_CHANGE) ! 285: s->socket.csc_mask |= SS_READY; ! 286: else ! 287: s->socket.csc_mask &= ~SS_READY; ! 288: if (s->ss_entry(s->sock, SS_SetSocket, &s->socket)) ! 289: return CS_GENERAL_FAILURE; ! 290: return CS_SUCCESS; ! 291: } ! 292: ! 293: int MTDHelperEntry(int func, void *a1, void *a2) ! 294: { ! 295: switch (func) { ! 296: case MTDRequestWindow: ! 297: return CardServices(RequestWindow, a1, a2, NULL); ! 298: case MTDReleaseWindow: ! 299: return CardServices(ReleaseWindow, a1, NULL, NULL); ! 300: case MTDModifyWindow: ! 301: return mtd_modify_window(a1, a2); break; ! 302: case MTDSetVpp: ! 303: return mtd_set_vpp(a1, a2); break; ! 304: case MTDRDYMask: ! 305: return mtd_rdy_mask(a1, a2); break; ! 306: default: ! 307: return CS_UNSUPPORTED_FUNCTION; break; ! 308: } ! 309: } /* MTDHelperEntry */ ! 310: ! 311: /*====================================================================== ! 312: ! 313: This stuff is used by Card Services to initialize the table of ! 314: region info used for subsequent calls to GetFirstRegion and ! 315: GetNextRegion. ! 316: ! 317: ======================================================================*/ ! 318: ! 319: static void setup_regions(client_handle_t handle, int attr, ! 320: memory_handle_t *list) ! 321: { ! 322: int i, code, has_jedec, has_geo; ! 323: u_int offset; ! 324: cistpl_device_t device; ! 325: cistpl_jedec_t jedec; ! 326: cistpl_device_geo_t geo; ! 327: memory_handle_t r; ! 328: ! 329: DEBUG(1, "cs: setup_regions(0x%p, %d, 0x%p)\n", ! 330: handle, attr, list); ! 331: ! 332: code = (attr) ? CISTPL_DEVICE_A : CISTPL_DEVICE; ! 333: if (read_tuple(handle, code, &device) != CS_SUCCESS) ! 334: return; ! 335: code = (attr) ? CISTPL_JEDEC_A : CISTPL_JEDEC_C; ! 336: has_jedec = (read_tuple(handle, code, &jedec) == CS_SUCCESS); ! 337: if (has_jedec && (device.ndev != jedec.nid)) { ! 338: #ifdef PCMCIA_DEBUG ! 339: printk(KERN_DEBUG "cs: Device info does not match JEDEC info.\n"); ! 340: #endif ! 341: has_jedec = 0; ! 342: } ! 343: code = (attr) ? CISTPL_DEVICE_GEO_A : CISTPL_DEVICE_GEO; ! 344: has_geo = (read_tuple(handle, code, &geo) == CS_SUCCESS); ! 345: if (has_geo && (device.ndev != geo.ngeo)) { ! 346: #ifdef PCMCIA_DEBUG ! 347: printk(KERN_DEBUG "cs: Device info does not match geometry tuple.\n"); ! 348: #endif ! 349: has_geo = 0; ! 350: } ! 351: ! 352: offset = 0; ! 353: for (i = 0; i < device.ndev; i++) { ! 354: if ((device.dev[i].type != CISTPL_DTYPE_NULL) && ! 355: (device.dev[i].size != 0)) { ! 356: r = kmalloc(sizeof(*r), GFP_KERNEL); ! 357: r->region_magic = REGION_MAGIC; ! 358: r->state = 0; ! 359: r->dev_info[0] = '\0'; ! 360: r->mtd = NULL; ! 361: r->info.Attributes = (attr) ? REGION_TYPE_AM : 0; ! 362: r->info.CardOffset = offset; ! 363: r->info.RegionSize = device.dev[i].size; ! 364: r->info.AccessSpeed = device.dev[i].speed; ! 365: if (has_jedec) { ! 366: r->info.JedecMfr = jedec.id[i].mfr; ! 367: r->info.JedecInfo = jedec.id[i].info; ! 368: } else ! 369: r->info.JedecMfr = r->info.JedecInfo = 0; ! 370: if (has_geo) { ! 371: r->info.BlockSize = geo.geo[i].buswidth * ! 372: geo.geo[i].erase_block * geo.geo[i].interleave; ! 373: r->info.PartMultiple = ! 374: r->info.BlockSize * geo.geo[i].partition; ! 375: } else ! 376: r->info.BlockSize = r->info.PartMultiple = 1; ! 377: r->info.next = *list; *list = r; ! 378: } ! 379: offset += device.dev[i].size; ! 380: } ! 381: } /* setup_regions */ ! 382: ! 383: /*====================================================================== ! 384: ! 385: This is tricky. When get_first_region() is called by Driver ! 386: Services, we initialize the region info table in the socket ! 387: structure. When it is called by an MTD, we can just scan the ! 388: table for matching entries. ! 389: ! 390: ======================================================================*/ ! 391: ! 392: static int match_region(client_handle_t handle, memory_handle_t list, ! 393: region_info_t *match) ! 394: { ! 395: while (list != NULL) { ! 396: if (!(handle->Attributes & INFO_MTD_CLIENT) || ! 397: (strcmp(handle->dev_info, list->dev_info) == 0)) { ! 398: *match = list->info; ! 399: return CS_SUCCESS; ! 400: } ! 401: list = list->info.next; ! 402: } ! 403: return CS_NO_MORE_ITEMS; ! 404: } /* match_region */ ! 405: ! 406: int get_first_region(client_handle_t handle, region_info_t *rgn) ! 407: { ! 408: socket_info_t *s = SOCKET(handle); ! 409: if (CHECK_HANDLE(handle)) ! 410: return CS_BAD_HANDLE; ! 411: ! 412: if ((handle->Attributes & INFO_MASTER_CLIENT) && ! 413: (!(s->state & SOCKET_REGION_INFO))) { ! 414: setup_regions(handle, 0, &s->c_region); ! 415: setup_regions(handle, 1, &s->a_region); ! 416: s->state |= SOCKET_REGION_INFO; ! 417: } ! 418: ! 419: if (rgn->Attributes & REGION_TYPE_AM) ! 420: return match_region(handle, s->a_region, rgn); ! 421: else ! 422: return match_region(handle, s->c_region, rgn); ! 423: } /* get_first_region */ ! 424: ! 425: int get_next_region(client_handle_t handle, region_info_t *rgn) ! 426: { ! 427: if (CHECK_HANDLE(handle)) ! 428: return CS_BAD_HANDLE; ! 429: return match_region(handle, rgn->next, rgn); ! 430: } /* get_next_region */ ! 431: ! 432: /*====================================================================== ! 433: ! 434: Connect an MTD with a memory region. ! 435: ! 436: ======================================================================*/ ! 437: ! 438: int register_mtd(client_handle_t handle, mtd_reg_t *reg) ! 439: { ! 440: memory_handle_t list; ! 441: socket_info_t *s; ! 442: ! 443: if (CHECK_HANDLE(handle)) ! 444: return CS_BAD_HANDLE; ! 445: s = SOCKET(handle); ! 446: if (reg->Attributes & REGION_TYPE_AM) ! 447: list = s->a_region; ! 448: else ! 449: list = s->c_region; ! 450: DEBUG(1, "cs: register_mtd(0x%p, '%s', 0x%x)\n", ! 451: handle, handle->dev_info, reg->Offset); ! 452: while (list) { ! 453: if (list->info.CardOffset == reg->Offset) break; ! 454: list = list->info.next; ! 455: } ! 456: if (list && (list->mtd == NULL) && ! 457: (strcmp(handle->dev_info, list->dev_info) == 0)) { ! 458: list->info.Attributes = reg->Attributes; ! 459: list->MediaID = reg->MediaID; ! 460: list->mtd = handle; ! 461: handle->mtd_count++; ! 462: return CS_SUCCESS; ! 463: } else ! 464: return CS_BAD_OFFSET; ! 465: } /* register_mtd */ ! 466: ! 467: /*====================================================================== ! 468: ! 469: Erase queue management functions ! 470: ! 471: ======================================================================*/ ! 472: ! 473: int register_erase_queue(client_handle_t *handle, eraseq_hdr_t *header) ! 474: { ! 475: eraseq_t *queue; ! 476: ! 477: if ((handle == NULL) || CHECK_HANDLE(*handle)) ! 478: return CS_BAD_HANDLE; ! 479: queue = kmalloc(sizeof(*queue), GFP_KERNEL); ! 480: if (!queue) return CS_OUT_OF_RESOURCE; ! 481: queue->eraseq_magic = ERASEQ_MAGIC; ! 482: queue->handle = *handle; ! 483: queue->count = header->QueueEntryCnt; ! 484: queue->entry = header->QueueEntryArray; ! 485: *handle = (client_handle_t)queue; ! 486: return CS_SUCCESS; ! 487: } /* register_erase_queue */ ! 488: ! 489: int deregister_erase_queue(eraseq_handle_t eraseq) ! 490: { ! 491: int i; ! 492: if (CHECK_ERASEQ(eraseq)) ! 493: return CS_BAD_HANDLE; ! 494: for (i = 0; i < eraseq->count; i++) ! 495: if (ERASE_IN_PROGRESS(eraseq->entry[i].State)) break; ! 496: if (i < eraseq->count) ! 497: return CS_BUSY; ! 498: eraseq->eraseq_magic = 0; ! 499: kfree(eraseq); ! 500: return CS_SUCCESS; ! 501: } /* deregister_erase_queue */ ! 502: ! 503: int check_erase_queue(eraseq_handle_t eraseq) ! 504: { ! 505: int i; ! 506: if (CHECK_ERASEQ(eraseq)) ! 507: return CS_BAD_HANDLE; ! 508: for (i = 0; i < eraseq->count; i++) ! 509: if (eraseq->entry[i].State == ERASE_QUEUED) ! 510: setup_erase_request(eraseq->handle, &eraseq->entry[i]); ! 511: return CS_SUCCESS; ! 512: } /* check_erase_queue */ ! 513: ! 514: /*====================================================================== ! 515: ! 516: Look up the memory region matching the request, and return a ! 517: memory handle. ! 518: ! 519: ======================================================================*/ ! 520: ! 521: int open_memory(client_handle_t *handle, open_mem_t *open) ! 522: { ! 523: socket_info_t *s; ! 524: memory_handle_t region; ! 525: ! 526: if ((handle == NULL) || CHECK_HANDLE(*handle)) ! 527: return CS_BAD_HANDLE; ! 528: s = SOCKET(*handle); ! 529: if (open->Attributes & MEMORY_TYPE_AM) ! 530: region = s->a_region; ! 531: else ! 532: region = s->c_region; ! 533: while (region) { ! 534: if (region->info.CardOffset == open->Offset) break; ! 535: region = region->info.next; ! 536: } ! 537: if (region && region->mtd) { ! 538: *handle = (client_handle_t)region; ! 539: DEBUG(1, "cs: open_memory(0x%p, 0x%x) = 0x%p\n", ! 540: handle, open->Offset, region); ! 541: return CS_SUCCESS; ! 542: } else ! 543: return CS_BAD_OFFSET; ! 544: } /* open_memory */ ! 545: ! 546: /*====================================================================== ! 547: ! 548: Close a memory handle from an earlier call to OpenMemory. ! 549: ! 550: For the moment, I don't think this needs to do anything. ! 551: ! 552: ======================================================================*/ ! 553: ! 554: int close_memory(memory_handle_t handle) ! 555: { ! 556: DEBUG(1, "cs: close_memory(0x%p)\n", handle); ! 557: if (CHECK_REGION(handle)) ! 558: return CS_BAD_HANDLE; ! 559: return CS_SUCCESS; ! 560: } /* close_memory */ ! 561: ! 562: /*====================================================================== ! 563: ! 564: Read from a memory device, using a handle previously returned ! 565: by a call to OpenMemory. ! 566: ! 567: ======================================================================*/ ! 568: ! 569: int read_memory(memory_handle_t handle, mem_op_t *req, caddr_t buf) ! 570: { ! 571: mtd_request_t mtd; ! 572: if (CHECK_REGION(handle)) ! 573: return CS_BAD_HANDLE; ! 574: if (req->Offset >= handle->info.RegionSize) ! 575: return CS_BAD_OFFSET; ! 576: if (req->Offset+req->Count > handle->info.RegionSize) ! 577: return CS_BAD_SIZE; ! 578: ! 579: mtd.SrcCardOffset = req->Offset + handle->info.CardOffset; ! 580: mtd.TransferLength = req->Count; ! 581: mtd.MediaID = handle->MediaID; ! 582: mtd.Function = MTD_REQ_READ; ! 583: if (req->Attributes & MEM_OP_BUFFER_KERNEL) ! 584: mtd.Function |= MTD_REQ_KERNEL; ! 585: return do_mtd_request(handle, &mtd, buf); ! 586: } /* read_memory */ ! 587: ! 588: /*====================================================================== ! 589: ! 590: Write to a memory device, using a handle previously returned by ! 591: a call to OpenMemory. ! 592: ! 593: ======================================================================*/ ! 594: ! 595: int write_memory(memory_handle_t handle, mem_op_t *req, caddr_t buf) ! 596: { ! 597: mtd_request_t mtd; ! 598: if (CHECK_REGION(handle)) ! 599: return CS_BAD_HANDLE; ! 600: if (req->Offset >= handle->info.RegionSize) ! 601: return CS_BAD_OFFSET; ! 602: if (req->Offset+req->Count > handle->info.RegionSize) ! 603: return CS_BAD_SIZE; ! 604: ! 605: mtd.DestCardOffset = req->Offset + handle->info.CardOffset; ! 606: mtd.TransferLength = req->Count; ! 607: mtd.MediaID = handle->MediaID; ! 608: mtd.Function = MTD_REQ_WRITE; ! 609: if (req->Attributes & MEM_OP_BUFFER_KERNEL) ! 610: mtd.Function |= MTD_REQ_KERNEL; ! 611: return do_mtd_request(handle, &mtd, buf); ! 612: } /* write_memory */ ! 613: ! 614: /*====================================================================== ! 615: ! 616: This isn't needed for anything I could think of. ! 617: ! 618: ======================================================================*/ ! 619: ! 620: int copy_memory(memory_handle_t handle, copy_op_t *req) ! 621: { ! 622: if (CHECK_REGION(handle)) ! 623: return CS_BAD_HANDLE; ! 624: return CS_UNSUPPORTED_FUNCTION; ! 625: } ! 626:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.